style:移除已经不用了的代码

models/data_manage/edb_data_calculate.go

@@ -1,13 +1,8 @@
 package data_manage
 
 import (
-	"errors"
 	"eta/eta_api/utils"
-	"fmt"
 	"github.com/beego/beego/v2/client/orm"
-	"github.com/yidane/formula"
-	"strconv"
-	"strings"
 	"time"
 )
 
@@ -23,12 +18,6 @@ type EdbDataCalculate struct {
 	DataTimestamp int64
 }
 
-func AddEdbDataCalculate(items []*EdbDataCalculate) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(1, items)
-	return
-}
-
 func AddEdbDataCalculateBySql(sqlStr string) (err error) {
 	o := orm.NewOrmUsingDB("data")
 	_, err = o.Raw(sqlStr).Exec()
@@ -49,126 +38,12 @@ func GetEdbDataCalculateByCodeAndDate(edbCode string, startDate string) (count i
 	return
 }
 
-// 刷新全部数据
-func RefreshAllCalculate(edbInfoIdArr []*EdbInfo, edbInfoId, source, subSource int, edbCode, formulaStr, startDate, endDate string, edbInfoIdBytes []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-	fmt.Println(startDate, endDate)
-	saveDataMap := make(map[string]map[int]float64)
-	for _, v := range edbInfoIdArr {
-		var condition string
-		var pars []interface{}
-		condition += " AND edb_info_id=? "
-		pars = append(pars, v.EdbInfoId)
-		if startDate != "" {
-			condition += " AND data_time>=? "
-			pars = append(pars, startDate)
-		}
-		if endDate != "" {
-			condition += " AND data_time<=? "
-			pars = append(pars, endDate)
-		}
-		fmt.Println("v.Source:", v.Source)
-		dataList, err := GetEdbDataListAll(condition, pars, v.Source, v.SubSource, 1)
-		if err != nil {
-			return err
-		}
-		dataMap := make(map[string]float64)
-		for _, dv := range dataList {
-			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
-			}
-		}
-		item := new(CalculateItems)
-		item.EdbInfoId = v.EdbInfoId
-		item.DataMap = dataMap
-	}
-
-	formulaMap := CheckFormula(formulaStr)
-	addSql := ` INSERT INTO edb_data_calculate(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-
-	//获取指标所有数据
-	dataList := make([]*EdbDataBase, 0)
-	dataTableName := GetEdbDataTableName(source, subSource)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = to.Raw(sql, edbInfoId).QueryRows(&dataList)
-	if err != nil {
-		return err
-	}
-	dataMap := make(map[string]string)
-	for _, v := range dataList {
-		dataMap[v.DataTime] = v.Value
-	}
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	existDataMap := make(map[string]string)
-	for sk, sv := range saveDataMap {
-		fmt.Println(sk, sv)
-		formulaStr = strings.ToUpper(formulaStr)
-		formulaFormStr := ReplaceFormula(edbInfoIdArr, sv, formulaMap, formulaStr, edbInfoIdBytes)
-		if formulaFormStr != "" {
-			utils.FileLog.Info("formulaFormStr:%s", formulaFormStr)
-			expression := formula.NewExpression(formulaFormStr)
-			calResult, err := expression.Evaluate()
-			if err != nil {
-				err = errors.New("计算失败：Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
-				fmt.Println(err)
-				return err
-			}
-			calVal, err := calResult.Float64()
-			if err != nil {
-				err = errors.New("计算失败：获取计算值失败 Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
-				fmt.Println(err)
-				return err
-			}
-
-			saveValue := utils.SubFloatToString(calVal, 4)
-			if existVal, ok := dataMap[sk]; !ok {
-				dataTime, _ := time.Parse(utils.FormatDate, sk)
-				timestamp := dataTime.UnixNano() / 1e6
-				timeStr := fmt.Sprintf("%d", timestamp)
-
-				if _, existOk := existDataMap[sk]; !existOk {
-					addSql += GetAddSql(edbInfoIdStr, edbCode, sk, timeStr, saveValue)
-					isAdd = true
-				}
-				existDataMap[sk] = sk
-			} else {
-				if existVal != saveValue {
-					sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-					sql = fmt.Sprintf(sql, dataTableName)
-					_, err = to.Raw(sql, saveValue, edbInfoId, sk).Exec()
-					if err != nil {
-						return err
-					}
-				}
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			fmt.Println("RefreshAllCalculate add Err", err.Error())
-			return
-		}
-	}
+func GetAddSql(edbInfoId, edbCode, dataTime, timestampStr string, value string) (addSql string) {
+	nowStr := time.Now().Format(utils.FormatDateTime)
+	addSql += "("
+	addSql += edbInfoId + "," + "'" + edbCode + "'" + "," + "'" + dataTime + "'" + "," + value + "," + "'" + nowStr + "'" +
+		"," + "'" + nowStr + "'" + "," + "1"
+	addSql += "," + "'" + timestampStr + "'"
+	addSql += "),"
 	return
 }

models/data_manage/edb_data_calculate_time_shift.go

@@ -1,552 +0,0 @@
-package data_manage
-
-import (
-	"errors"
-	"eta/eta_api/utils"
-	"fmt"
-	"github.com/beego/beego/v2/client/orm"
-	"github.com/shopspring/decimal"
-	"strconv"
-	"strings"
-	"time"
-)
-
-//时间移位
-
-type EdbInfoCalculateMove struct {
-	EdbInfoCalculateBpId int       `orm:"column(edb_info_calculate_bp_id);pk"`
-	EdbInfoId            int       `description:"指标id"`
-	EdbCode              string    `description:"指标编码"`
-	FromEdbInfoId        int       `description:"计算指标id"`
-	FromEdbCode          string    `description:"计算指标编码"`
-	FromEdbName          string    `description:"计算指标名称"`
-	FromSource           int       `description:"计算指标来源"`
-	FromSourceName       string    `description:"计算指标来源名称"`
-	FromTag              string    `description:"来源指标标签"`
-	Sort                 int       `description:"计算指标名称排序"`
-	CreateTime           time.Time `description:"创建时间"`
-	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")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			fmt.Println("AddCalculateTimeShift,Err:" + err.Error())
-			_ = to.Rollback()
-		} else {
-			_ = to.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, tmpErr := to.Insert(edbInfo)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-		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
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-	} else {
-		edbInfoId = req.EdbInfoId
-		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SUB_SOURCE_EDB)
-		fmt.Println("dataTableName:" + dataTableName)
-		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
-		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = to.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, fromEdbInfo.SubSource, 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 = to.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")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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 = to.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 = to.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 = "时间移位"
-				_, err = to.Insert(calculateMappingItem)
-				if err != nil {
-					return
-				}
-			}
-		}
-		//清空原有数据
-		sql = ` DELETE FROM edb_data_calculate_time_shift WHERE edb_info_id = ? `
-		_, err = to.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, fromEdbInfo.SubSource, 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 = to.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")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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, fromEdbInfo.SubSource, 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 = to.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"`
-	EdbCode              string    `description:"指标编码"`
-	FromEdbInfoId        int       `description:"计算指标id"`
-	FromEdbCode          string    `description:"计算指标编码"`
-	FromEdbName          string    `description:"计算指标名称"`
-	FromSource           int       `description:"计算指标来源"`
-	FromSourceName       string    `description:"计算指标来源名称"`
-	FromTag              string    `description:"来源指标标签"`
-	Sort                 int       `description:"计算指标名称排序"`
-	CreateTime           time.Time `description:"创建时间"`
-	ModifyTime           time.Time `description:"修改时间"`
-	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, subSource, formulaInt, moveType int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate, moveFrequency string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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, fromEdbInfo.SubSource, 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, subSource)
-	fmt.Println("dataTableName:", dataTableName)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = to.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 = to.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 = to.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}

models/data_manage/edb_info.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"github.com/beego/beego/v2/client/orm"
 	"github.com/rdlucklib/rdluck_tools/paging"
-	"strconv"
 	"strings"
 	"time"
 )
@@ -1010,341 +1009,6 @@ func ReplaceChartEdb(oldEdbInfo, newEdbInfo *EdbInfo) (relationEdbInfoIdList []i
 	return
 }
 
-// replaceRelationEdbInfo 替换关联指标
-func replaceRelationEdbInfo(mappingList []*EdbInfoCalculateMapping, oldEdbInfo, newEdbInfo *EdbInfo, sysAdminId int, sysAdminRealName string) (err error) {
-	errmsg := ``
-	defer func() {
-		if errmsg != "" {
-			fmt.Println("errmsg:" + errmsg)
-		}
-		if err != nil && errmsg != "" {
-			go alarm_msg.SendAlarmMsg("替换关联指标失败提醒,errmsg："+errmsg, 3)
-			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"替换指标失败提醒", "errmsg:"+errmsg, utils.EmailSendToUsers)
-		}
-	}()
-	//获取计算指标关联指标
-	allMappingList := make([]*EdbInfoCalculateMapping, 0)
-	allMapping := make(map[int]int)
-	tmpMapping := make(map[int]int)
-	for _, v := range mappingList {
-		if _, ok := allMapping[v.EdbInfoId]; !ok {
-			allMappingList = append(allMappingList, v)
-		}
-		newList, _ := GetAllCalculateV2(v.EdbInfoId, newEdbInfo.EdbInfoId, tmpMapping)
-		for _, nv := range newList {
-			if _, ok := allMapping[v.EdbInfoId]; !ok {
-				allMappingList = append(allMappingList, nv)
-			}
-			allMapping[v.EdbInfoId] = v.EdbInfoId
-		}
-		allMapping[v.EdbInfoId] = v.EdbInfoId
-	}
-	for mk, mv := range allMappingList { //原指标关联的所有计算指标
-		fmt.Println("mk/mv", mk, mv)
-		//重新计算计算指标
-		{
-			edbInfo, tmpErr := GetEdbInfoById(mv.EdbInfoId) //计算指标
-			err = tmpErr
-			if err != nil {
-				if err.Error() == utils.ErrNoRow() {
-					errmsg = "计算指标已被删除"
-				} else {
-					errmsg = "获取计算指标失败:err:" + err.Error()
-				}
-				return
-			}
-
-			fromEdbInfoList, tmpErr := GetEdbInfoCalculateDetail(mv.EdbInfoId, edbInfo.Source)
-			err = tmpErr
-			if err != nil {
-				errmsg = "获取计算指标失败:err:" + err.Error()
-				return
-			}
-			if len(fromEdbInfoList) <= 0 {
-				errmsg = "计算指标所依赖指标不存在"
-				err = fmt.Errorf("计算指标所依赖指标不存在")
-				return
-			}
-			fromEdbInfoItem := fromEdbInfoList[0]
-			if fromEdbInfoItem == nil {
-				return
-			}
-			fromEdbInfo, tmpErr := GetEdbInfoById(fromEdbInfoItem.FromEdbInfoId)
-			err = tmpErr
-			if err != nil {
-				errmsg = "获取计算指标 来源指标失败:err:" + err.Error()
-				return
-			}
-			edbCode := edbInfo.EdbCode
-			uniqueCode := edbInfo.UniqueCode
-			sourName := edbInfo.SourceName
-			source := edbInfo.Source
-			subSource := edbInfo.SubSource
-			edbInfoId := edbInfo.EdbInfoId
-
-			req := new(EdbInfoCalculateBatchSaveReq)
-			req.EdbInfoId = edbInfoId
-			req.EdbName = edbInfo.EdbName
-			req.Frequency = edbInfo.Frequency
-			req.Unit = edbInfo.Unit
-			req.ClassifyId = edbInfo.ClassifyId
-			req.FromEdbInfoId = fromEdbInfoList[0].FromEdbInfoId
-
-			if source == utils.DATA_SOURCE_CALCULATE {
-				//检验公式
-				var formulaStr string
-				var edbInfoIdBytes []string
-				for _, v := range fromEdbInfoList {
-					formulaStr += v.FromTag + ","
-					edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
-				}
-				formulaStr = strings.Trim(formulaStr, ",")
-				formulaMap := CheckFormula(edbInfo.CalculateFormula)
-				for _, v := range formulaMap {
-					if !strings.Contains(formulaStr, v) {
-						errmsg = "公式错误，请重新填写"
-						err = fmt.Errorf("公式错误，请重新填写")
-						return
-					}
-				}
-
-				edbInfoList := make([]*EdbInfo, 0)
-
-				for _, v := range fromEdbInfoList {
-					edbInfo, tmpErr := GetEdbInfoById(v.FromEdbInfoId)
-					err = tmpErr
-					if err != nil {
-						if err.Error() == utils.ErrNoRow() {
-							errmsg = "指标 " + strconv.Itoa(v.FromEdbInfoId) + " 不存在"
-						} else {
-							errmsg = "获取指标失败:Err:" + err.Error()
-						}
-						return
-					}
-					edbInfoList = append(edbInfoList, edbInfo)
-				}
-				//清除历史数据
-				err = DeleteCalculateData(edbInfoId)
-				if err != nil {
-					errmsg = "清空运算指标失败:Err:" + err.Error() + " edb_info_id:" + strconv.Itoa(edbInfoId)
-					return
-				}
-				err = Calculate(edbInfoList, int(edbInfoId), edbCode, edbInfo.CalculateFormula, edbInfoIdBytes)
-				if err != nil {
-					errmsg = "生成计算指标失败,Calculate Err:" + err.Error()
-					return
-				}
-			} else if source == utils.DATA_SOURCE_CALCULATE_LJZZY {
-				_, err = AddCalculateLjzzy(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName)
-			} else if source == utils.DATA_SOURCE_CALCULATE_TBZ {
-				sourName = "同比值"
-				edbInfoId, err = AddCalculateTbz(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName)
-			} else if source == utils.DATA_SOURCE_CALCULATE_TCZ {
-				sourName = "同差值"
-				edbInfoId, err = AddCalculateTcz(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName)
-			} else if source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS {
-				sourName = "N数值移动平均计算"
-				formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
-				edbInfoId, err = AddCalculateNszydpjjs(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName, formulaInt)
-			} else if source == utils.DATA_SOURCE_CALCULATE_HBZ {
-				sourName = "环比值"
-				formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
-				edbInfoId, err = AddCalculateHbz(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName, formulaInt)
-			} else if source == utils.DATA_SOURCE_CALCULATE_HCZ {
-				sourName = "环差值"
-				formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
-				edbInfoId, err = AddCalculateHcz(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName, formulaInt)
-			} else if source == utils.DATA_SOURCE_CALCULATE_BP {
-				sourName = "变频"
-				fmt.Println("变频", req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName)
-				edbInfoId, err = AddCalculateBp(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName)
-			} else if source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT {
-				req2 := &EdbInfoCalculateBatchEditReq{
-					EdbName:       edbInfo.EdbName,
-					Frequency:     edbInfo.Frequency,
-					Unit:          edbInfo.Unit,
-					ClassifyId:    edbInfo.ClassifyId,
-					Formula:       edbInfo.CalculateFormula,
-					EdbInfoId:     edbInfo.EdbInfoId,
-					FromEdbInfoId: fromEdbInfoList[0].FromEdbInfoId,
-					Source:        edbInfo.Source,
-					MoveType:      edbInfo.MoveType,
-					MoveFrequency: edbInfo.MoveFrequency,
-				}
-				sourName = "时间移位"
-				edbInfoId, err = EditCalculateTimeShift(req2, fromEdbInfo, edbCode, edbInfo)
-			} else if source == utils.DATA_SOURCE_CALCULATE_ZJPJ {
-				edbInfoIdArr := make([]EdbInfoFromTag, 0)
-				//A指标
-				aFromEdbInfoId := fromEdbInfoList[0].FromEdbInfoId
-				for _, v := range fromEdbInfoList {
-					if v.FromTag == "A" {
-						if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
-							aFromEdbInfoId = newEdbInfo.EdbInfoId
-						} else {
-							aFromEdbInfoId = fromEdbInfoList[0].FromEdbInfoId
-						}
-					}
-					if v.FromTag == "B" {
-						if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
-							edbInfoIdArr = append(edbInfoIdArr, EdbInfoFromTag{
-								EdbInfoId: newEdbInfo.EdbInfoId,
-								FromTag:   v.FromTag,
-								MoveValue: v.MoveValue,
-							})
-						} else {
-							edbInfoIdArr = append(edbInfoIdArr, EdbInfoFromTag{
-								EdbInfoId: v.FromEdbInfoId,
-								FromTag:   v.FromTag,
-								MoveValue: v.MoveValue,
-							})
-						}
-					}
-				}
-				req2 := &EdbInfoCalculateBatchEditReq{
-					EdbName:       edbInfo.EdbName,
-					Frequency:     edbInfo.Frequency,
-					Unit:          edbInfo.Unit,
-					ClassifyId:    edbInfo.ClassifyId,
-					Formula:       edbInfo.CalculateFormula,
-					EdbInfoId:     edbInfo.EdbInfoId,
-					FromEdbInfoId: aFromEdbInfoId,
-					Source:        edbInfo.Source,
-					MoveType:      edbInfo.MoveType,
-					MoveFrequency: edbInfo.MoveFrequency,
-					EdbInfoIdArr:  edbInfoIdArr,
-				}
-
-				sourName = "直接拼接"
-				if len(req2.EdbInfoIdArr) != 1 {
-					errmsg = "请传入拼接日期之后的指标"
-					err = fmt.Errorf("请传入拼接日期之后的指标")
-					return
-				}
-
-				secondEdbInfoReq := req2.EdbInfoIdArr[0]
-				secondEdbInfo, tmpErr := GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
-				err = tmpErr
-				if err != nil {
-					errmsg = "获取拼接日期之后的指标信息失败:Err:" + err.Error()
-					err = fmt.Errorf("获取拼接日期之后的指标信息失败:Err:" + err.Error())
-					return
-				}
-
-				if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
-					errmsg = "两个指标不允许为同一个"
-					err = fmt.Errorf("两个指标不允许为同一个")
-					return
-				}
-				tmpEdbInfoId, tmpErr := EditCalculateZjpj(req2, edbInfo, fromEdbInfo, secondEdbInfo)
-				err = tmpErr
-				edbInfoId = tmpEdbInfoId
-			} else if source == utils.DATA_SOURCE_CALCULATE_LJZTBPJ { //累计值同比拼接
-				edbInfoIdArr := make([]EdbInfoFromTag, 0)
-				//A指标
-				aFromEdbInfoId := fromEdbInfoList[0].FromEdbInfoId
-				for _, v := range fromEdbInfoList {
-					if v.FromTag == "A" {
-						if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
-							aFromEdbInfoId = newEdbInfo.EdbInfoId
-						} else {
-							aFromEdbInfoId = fromEdbInfoList[0].FromEdbInfoId
-						}
-					}
-					if v.FromTag == "B" {
-						if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
-							edbInfoIdArr = append(edbInfoIdArr, EdbInfoFromTag{
-								EdbInfoId: newEdbInfo.EdbInfoId,
-								FromTag:   v.FromTag,
-								MoveValue: v.MoveValue,
-							})
-						} else {
-							edbInfoIdArr = append(edbInfoIdArr, EdbInfoFromTag{
-								EdbInfoId: v.FromEdbInfoId,
-								FromTag:   v.FromTag,
-								MoveValue: v.MoveValue,
-							})
-						}
-					}
-				}
-
-				req2 := &EdbInfoCalculateBatchEditReq{
-					EdbName:       edbInfo.EdbName,
-					Frequency:     edbInfo.Frequency,
-					Unit:          edbInfo.Unit,
-					ClassifyId:    edbInfo.ClassifyId,
-					Formula:       edbInfo.CalculateFormula,
-					EdbInfoId:     edbInfo.EdbInfoId,
-					FromEdbInfoId: aFromEdbInfoId,
-					Source:        edbInfo.Source,
-					MoveType:      edbInfo.MoveType,
-					MoveFrequency: edbInfo.MoveFrequency,
-					EdbInfoIdArr:  edbInfoIdArr,
-				}
-
-				sourName = "累计值同比拼接"
-
-				if fromEdbInfo.Frequency != "月度" {
-					errmsg = "累计值同比拼接,待拼接指标只能筛选月度指标"
-					err = fmt.Errorf("累计值同比拼接,待拼接指标只能筛选月度指标")
-					return
-				}
-				if len(req2.EdbInfoIdArr) != 1 {
-					errmsg = "请传入同比值指标"
-					err = fmt.Errorf("请传入同比值指标")
-					return
-				}
-
-				secondEdbInfoReq := req2.EdbInfoIdArr[0]
-				tbzEdbInfo, tmpErr := GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
-				err = tmpErr
-				if err != nil {
-					errmsg = "获取同比值指标信息失败:Err:" + err.Error()
-					err = fmt.Errorf("获取同比值指标信息失败:Err:" + err.Error())
-					return
-				}
-				if tbzEdbInfo.Source != utils.DATA_SOURCE_CALCULATE_TBZ {
-					errmsg = "指标必须是传入同比值指标类型"
-					err = fmt.Errorf("指标必须是传入同比值指标类型")
-					return
-				}
-				if tbzEdbInfo.Frequency != "月度" {
-					errmsg = "同比值指标只能筛选月度指标"
-					err = fmt.Errorf("同比值指标只能筛选月度指标")
-					return
-				}
-
-				if fromEdbInfo.EdbInfoId == tbzEdbInfo.EdbInfoId {
-					errmsg = "两个指标不允许为同一个"
-					err = fmt.Errorf("两个指标不允许为同一个")
-					return
-				}
-				tmpEdbInfoId, tmpErr := EditCalculateLjztbpj(req2, edbInfo, fromEdbInfo, tbzEdbInfo)
-				err = tmpErr
-				edbInfoId = tmpEdbInfoId
-			} else if source == utils.DATA_SOURCE_PYTHON {
-				//python代码运算的过滤
-				continue
-			} else {
-				errmsg = "无效计算方式,source:" + strconv.Itoa(source)
-				err = fmt.Errorf("无效计算方式,source:" + strconv.Itoa(source))
-				return
-			}
-			maxAndMinItem, tmpErr := GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
-			err = tmpErr
-			if err != nil && err.Error() != utils.ErrNoRow() {
-				errmsg = "生成" + sourName + "失败,GetEdbInfoMaxAndMinInfo Err:" + err.Error()
-				err = fmt.Errorf("生成" + sourName + "失败,GetEdbInfoMaxAndMinInfo Err:" + err.Error())
-				return
-			}
-			if maxAndMinItem != nil {
-				err = ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
-			}
-		}
-	}
-	return
-}
-
 type EdbInfoView struct {
 	EdbInfoId        int    `orm:"column(edb_info_id);pk"`
 	EdbInfoType      int    `description:"指标类型，0：普通指标，1：预测指标"`

models/data_manage/edb_info_calculate_bp.go

@@ -1,601 +0,0 @@
-package data_manage
-
-import (
-	"errors"
-	"eta/eta_api/utils"
-	"fmt"
-	"github.com/beego/beego/v2/client/orm"
-	"github.com/shopspring/decimal"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type EdbInfoCalculateBp struct {
-	EdbInfoCalculateBpId int       `orm:"column(edb_info_calculate_bp_id);pk"`
-	EdbInfoId            int       `description:"指标id"`
-	EdbCode              string    `description:"指标编码"`
-	FromEdbInfoId        int       `description:"计算指标id"`
-	FromEdbCode          string    `description:"计算指标编码"`
-	FromEdbName          string    `description:"计算指标名称"`
-	FromSource           int       `description:"计算指标来源"`
-	FromSourceName       string    `description:"计算指标来源名称"`
-	FromTag              string    `description:"来源指标标签"`
-	Sort                 int       `description:"计算指标名称排序"`
-	CreateTime           time.Time `description:"创建时间"`
-	ModifyTime           time.Time `description:"修改时间"`
-}
-
-// 变频
-func AddCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
-	fmt.Println("AddCalculateBp")
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			fmt.Println("AddCalculateBp,Err:" + err.Error())
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
-		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_BP
-		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
-		newEdbInfoId, tmpErr := to.Insert(edbInfo)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-		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
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-	} else {
-		edbInfoId = req.EdbInfoId
-		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_BP, utils.DATA_SUB_SOURCE_EDB)
-		fmt.Println("dataTableName:" + dataTableName)
-		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
-		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
-		if err != nil {
-			return 0, err
-		}
-	}
-
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	fmt.Println("edbInfoIdStr:" + edbInfoIdStr)
-	//计算数据
-	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, fromEdbInfo.SubSource, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_bp(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)
-	fmt.Println("dataLen:", dataLen)
-
-	for i := 0; i < dataLen; i++ {
-		//当期
-		currentItem := dataList[i]
-		currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-		var day int
-		var preItem *EdbInfoSearchData
-		var preDate time.Time
-		if i == 0 {
-			day = int(time.Now().Sub(currentDate).Hours() / float64(24))
-			preDate = time.Now()
-		} else {
-			j := i - 1
-			if j < dataLen {
-				preItem = dataList[j]
-				preDate, _ = time.Parse(utils.FormatDate, preItem.DataTime)
-				day = int(preDate.Sub(currentDate).Hours() / float64(24))
-				utils.FileLog.Info("preItem.DataTime:" + preItem.DataTime + ";currentItem.DataTime" + currentItem.DataTime)
-			}
-		}
-		for k := 0; k <= day; k++ {
-			needDay := preDate.AddDate(0, 0, -k)
-			needDayStr := needDay.Format(utils.FormatDate)
-			existKey := edbCode + needDayStr
-			if _, ok := existMap[existKey]; !ok {
-				timestamp := needDay.UnixNano() / 1e6
-				timestampStr := fmt.Sprintf("%d", timestamp)
-				valStr := decimal.NewFromFloat(currentItem.Value).String()
-				addSql += GetAddSql(edbInfoIdStr, edbCode, needDayStr, timestampStr, valStr)
-				isAdd = true
-			}
-			existMap[existKey] = needDayStr
-		}
-		existKey := edbCode + currentItem.DataTime
-		if _, ok := existMap[existKey]; !ok {
-			currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-			timestamp := currentDate.UnixNano() / 1e6
-			timestampStr := fmt.Sprintf("%d", timestamp)
-			valStr := decimal.NewFromFloat(currentItem.Value).String()
-			addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, valStr)
-			isAdd = true
-		}
-		existMap[existKey] = currentItem.DataTime
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
-	return
-}
-
-// 环比值
-func EditCalculateBp(req *EdbInfoCalculateBatchEditReq, fromEdbInfo *EdbInfo, edbCode string) (edbInfoId int, err error) {
-	edbInfoId = req.EdbInfoId
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-
-	//修改指标信息
-	sql := ` UPDATE  edb_info
-			SET
-			  edb_name =?,
-			  edb_name_source=?,
-			  frequency = ?,
-			  unit = ?,
-			  classify_id = ?,
-			  modify_time = NOW()
-			WHERE edb_info_id = ? `
-	_, err = to.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, 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 {
-		//删除指标关联计算指标
-		//sql := ` DELETE FROM edb_info_calculate_bp WHERE edb_info_id = ? `
-		//_, err = to.Raw(sql, edbInfoId).Exec()
-		//if err != nil {
-		//	return
-		//}
-
-		//calculateItem := new(EdbInfoCalculateHbz)
-		//calculateItem.CreateTime = time.Now()
-		//calculateItem.ModifyTime = time.Now()
-		//calculateItem.Sort = 1
-		//calculateItem.EdbCode = edbCode
-		//calculateItem.EdbInfoId = edbInfoId
-		//calculateItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
-		//calculateItem.FromEdbCode = fromEdbInfo.EdbCode
-		//calculateItem.FromEdbName = fromEdbInfo.EdbName
-		//calculateItem.FromSource = fromEdbInfo.Source
-		//calculateItem.FromSourceName = fromEdbInfo.SourceName
-		//
-		//_, err = to.Insert(calculateItem)
-		//if err != nil {
-		//	return
-		//}
-
-		//删除，计算指标关联的，基础指标的关联关系
-		sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			err = errors.New("删除计算指标关联关系失败,Err:" + err.Error())
-			return
-		}
-		//清空原有数据
-		sql = ` DELETE FROM edb_data_calculate_bp WHERE edb_info_id = ? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-		//关联关系
-		{
-			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_BP
-			calculateMappingItem.SourceName = "变频"
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-		edbInfoIdStr := strconv.Itoa(edbInfoId)
-		fmt.Println("edbInfoIdStr:" + edbInfoIdStr)
-		//计算数据
-		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, fromEdbInfo.SubSource, 0)
-		if err != nil {
-			return edbInfoId, err
-		}
-		addSql := ` INSERT INTO edb_data_calculate_bp(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]
-			currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-			var day int
-			var preItem *EdbInfoSearchData
-			var preDate time.Time
-			if i == 0 {
-				day = int(time.Now().Sub(currentDate).Hours() / float64(24))
-				preDate = time.Now()
-			} else {
-				j := i + 1
-				if j < dataLen {
-					preItem = dataList[j]
-					preDate, _ = time.Parse(utils.FormatDate, preItem.DataTime)
-					day = int(currentDate.Sub(preDate).Hours() / float64(24))
-				}
-			}
-			for k := 0; k <= day; k++ {
-				needDay := preDate.AddDate(0, 0, -k)
-				needDayStr := needDay.Format(utils.FormatDate)
-				existKey := edbCode + needDayStr
-				if _, ok := existMap[existKey]; !ok {
-					timestamp := needDay.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					valStr := decimal.NewFromFloat(currentItem.Value).String()
-					addSql += GetAddSql(edbInfoIdStr, edbCode, needDayStr, timestampStr, valStr)
-				}
-				existMap[existKey] = needDayStr
-			}
-			existKey := edbCode + currentItem.DataTime
-			if _, ok := existMap[existKey]; !ok {
-				currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-				timestamp := currentDate.UnixNano() / 1e6
-				timestampStr := fmt.Sprintf("%d", timestamp)
-				valStr := decimal.NewFromFloat(currentItem.Value).String()
-				addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, valStr)
-			}
-			existMap[existKey] = currentItem.DataTime
-		}
-		if isAdd {
-			addSql = strings.TrimRight(addSql, ",")
-			_, err = to.Raw(addSql).Exec()
-			if err != nil {
-				return edbInfoId, err
-			}
-		}
-	}
-	return
-}
-
-// 变频
-func RefreshCalculateBp(edbInfoId int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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)
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 0)
-	if err != nil {
-		return err
-	}
-	existMap := make(map[string]string)
-	dataLen := len(dataList)
-	addSql := ` INSERT INTO edb_data_calculate_bp(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]
-		currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-		var day int
-		var preItem *EdbInfoSearchData
-		var preDate time.Time
-		if i == 0 {
-			day = int(time.Now().Sub(currentDate).Hours() / float64(24))
-			preDate = time.Now()
-		} else {
-			j := i + 1
-			if j < dataLen {
-				preItem = dataList[j]
-				preDate, _ = time.Parse(utils.FormatDate, preItem.DataTime)
-				day = int(currentDate.Sub(preDate).Hours() / float64(24))
-			}
-		}
-		for k := 0; k <= day; k++ {
-			needDay := preDate.AddDate(0, 0, -k)
-			needDayStr := needDay.Format(utils.FormatDate)
-			existKey := edbCode + needDayStr
-			if _, ok := existMap[existKey]; !ok {
-				timestamp := needDay.UnixNano() / 1e6
-				timestampStr := fmt.Sprintf("%d", timestamp)
-				valStr := decimal.NewFromFloat(currentItem.Value).String()
-				addSql += GetAddSql(edbInfoIdStr, edbCode, needDayStr, timestampStr, valStr)
-			}
-			existMap[existKey] = needDayStr
-		}
-		existKey := edbCode + currentItem.DataTime
-		if _, ok := existMap[existKey]; !ok {
-			currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-			timestamp := currentDate.UnixNano() / 1e6
-			timestampStr := fmt.Sprintf("%d", timestamp)
-			valStr := decimal.NewFromFloat(currentItem.Value).String()
-			addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, valStr)
-		}
-		existMap[existKey] = currentItem.DataTime
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}
-
-type EdbInfoCalculateBpDetail struct {
-	EdbInfoCalculateBpId int       `orm:"column(edb_info_calculate_bp_id);pk"`
-	EdbInfoId            int       `description:"指标id"`
-	EdbCode              string    `description:"指标编码"`
-	FromEdbInfoId        int       `description:"计算指标id"`
-	FromEdbCode          string    `description:"计算指标编码"`
-	FromEdbName          string    `description:"计算指标名称"`
-	FromSource           int       `description:"计算指标来源"`
-	FromSourceName       string    `description:"计算指标来源名称"`
-	FromTag              string    `description:"来源指标标签"`
-	Sort                 int       `description:"计算指标名称排序"`
-	CreateTime           time.Time `description:"创建时间"`
-	ModifyTime           time.Time `description:"修改时间"`
-	StartDate            string    `description:"开始日期"`
-	EndDate              string    `description:"结束日期"`
-}
-
-func GetEdbInfoCalculateBpDetail(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 RefreshAllCalculateBp(edbInfoId, source, subSource int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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)
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 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
-	}
-	//获取指标所有数据
-	existDataList := make([]*EdbDataBase, 0)
-	dataTableName := GetEdbDataTableName(source, subSource)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
-	if err != nil {
-		return err
-	}
-	existDataMap := make(map[string]string)
-	for _, v := range existDataList {
-		existDataMap[v.DataTime] = v.Value
-	}
-	addSql := ` INSERT INTO edb_data_calculate_bp(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]
-		currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-		var day int
-		var preItem *EdbInfoSearchData
-		var preDate time.Time
-		if i == 0 {
-			day = int(time.Now().Sub(currentDate).Hours() / float64(24))
-			preDate = time.Now()
-		} else {
-			j := i + 1
-			if j < dataLen {
-				preItem = dataList[j]
-				preDate, _ = time.Parse(utils.FormatDate, preItem.DataTime)
-				day = int(currentDate.Sub(preDate).Hours() / float64(24))
-			}
-		}
-		for k := 0; k <= day; k++ {
-			needDay := preDate.AddDate(0, 0, -k)
-			needDayStr := needDay.Format(utils.FormatDate)
-			existKey := edbCode + needDayStr
-			if _, ok := existMap[existKey]; !ok {
-				timestamp := needDay.UnixNano() / 1e6
-				timestampStr := fmt.Sprintf("%d", timestamp)
-				valStr := decimal.NewFromFloat(currentItem.Value).String()
-				if existVal, ok := existDataMap[needDayStr]; !ok {
-					addSql += GetAddSql(edbInfoIdStr, edbCode, needDayStr, 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 = to.Raw(sql, valStr, edbInfoId, needDay).Exec()
-						if err != nil {
-							return err
-						}
-					}
-				}
-			}
-			existMap[existKey] = needDayStr
-		}
-		existKey := edbCode + currentItem.DataTime
-		if _, ok := existMap[existKey]; !ok {
-			currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-			timestamp := currentDate.UnixNano() / 1e6
-			timestampStr := fmt.Sprintf("%d", timestamp)
-			valStr := decimal.NewFromFloat(currentItem.Value).String()
-			if existVal, ok := existDataMap[currentItem.DataTime]; !ok {
-				addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, 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 = to.Raw(sql, valStr, edbInfoId, currentItem.DataTime).Exec()
-					if err != nil {
-						return err
-					}
-				}
-			}
-		}
-		existMap[existKey] = currentItem.DataTime
-	}
-
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}

models/data_manage/edb_info_calculate_hbz.go

@@ -1,526 +0,0 @@
-package data_manage
-
-import (
-	"errors"
-	"eta/eta_api/utils"
-	"fmt"
-	"github.com/beego/beego/v2/client/orm"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/shopspring/decimal"
-)
-
-type EdbInfoCalculateHbz struct {
-	EdbInfoCalculateHbzId int       `orm:"column(edb_info_calculate_hbz_id);pk"`
-	EdbInfoId             int       `description:"指标id"`
-	EdbCode               string    `description:"指标编码"`
-	FromEdbInfoId         int       `description:"计算指标id"`
-	FromEdbCode           string    `description:"计算指标编码"`
-	FromEdbName           string    `description:"计算指标名称"`
-	FromSource            int       `description:"计算指标来源"`
-	FromSourceName        string    `description:"计算指标来源名称"`
-	FromTag               string    `description:"来源指标标签"`
-	Sort                  int       `description:"计算指标名称排序"`
-	CreateTime            time.Time `description:"创建时间"`
-	ModifyTime            time.Time `description:"修改时间"`
-}
-
-// 环比值
-func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfoId int, err error) {
-	fmt.Println("AddCalculateHbz")
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			fmt.Println("AddCalculateHbz,Err:" + err.Error())
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
-		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_HBZ
-		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
-		newEdbInfoId, tmpErr := to.Insert(edbInfo)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-		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
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-	} else {
-		edbInfoId = req.EdbInfoId
-		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SUB_SOURCE_EDB)
-		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
-		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
-	}
-
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	fmt.Println("edbInfoIdStr:" + edbInfoIdStr)
-	//计算数据
-	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, fromEdbInfo.SubSource, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_hbz(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++ {
-		j := i + formulaInt
-		if j < dataLen {
-			//当期
-			currentItem := dataList[i]
-			preItem := dataList[j]
-			fmt.Println("preItem.Value:", preItem.Value)
-			if currentItem != nil && preItem != nil && preItem.Value != 0 {
-				existKey := edbCode + currentItem.DataTime
-				if _, ok := existMap[existKey]; !ok {
-					currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					val := HbzDiv(currentItem.Value, preItem.Value)
-					if val != "" {
-						addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, val)
-						isAdd = true
-					}
-				}
-				existMap[existKey] = currentItem.DataTime
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
-	return
-}
-
-// 环比值，current:当期,pre:上期 公式: (当期-上期）/上期
-func HbzDiv(current, pre float64) string {
-	if pre == 0 {
-		return ""
-	}
-	currentVal := decimal.NewFromFloat(float64(current))
-	preVal := decimal.NewFromFloat(float64(pre))
-	val, _ := currentVal.Sub(preVal).Div(preVal).Float64()
-	valStr := utils.SubFloatToString(val, 4)
-	return valStr
-}
-
-// 环比值
-func EditCalculateHbz(req *EdbInfoCalculateBatchEditReq, fromEdbInfo *EdbInfo, edbCode string, formulaInt int, calculateFormula string) (edbInfoId int, err error) {
-	edbInfoId = req.EdbInfoId
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-
-	//修改指标信息
-	sql := ` UPDATE  edb_info
-			SET
-			  edb_name =?,
-			  edb_name_source=?,
-			  frequency = ?,
-			  unit = ?,
-			  classify_id = ?,
- 			  calculate_formula=?,
-			  modify_time = NOW()
-			WHERE edb_info_id = ? `
-	_, err = to.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, 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 || strconv.Itoa(formulaInt) != calculateFormula {
-		//删除，计算指标关联的，基础指标的关联关系
-		if count <= 0 {
-			sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-			_, err = to.Raw(sql, edbInfoId).Exec()
-			if err != nil {
-				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_HBZ
-				calculateMappingItem.SourceName = "环比值"
-				_, err = to.Insert(calculateMappingItem)
-				if err != nil {
-					return
-				}
-			}
-		}
-		//清空原有数据
-		sql = ` DELETE FROM edb_data_calculate_hbz WHERE edb_info_id = ? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-		edbInfoIdStr := strconv.Itoa(edbInfoId)
-		//计算数据
-		var condition string
-		var pars []interface{}
-		condition += " AND edb_info_id=? "
-		pars = append(pars, req.FromEdbInfoId)
-		dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 0)
-		if err != nil {
-			return edbInfoId, err
-		}
-		addSql := ` INSERT INTO edb_data_calculate_hbz(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++ {
-			j := i + formulaInt
-			if j < dataLen {
-				//当期
-				currentItem := dataList[i]
-				preItem := dataList[j]
-				if currentItem != nil && preItem != nil {
-					existKey := edbCode + currentItem.DataTime
-					if _, ok := existMap[existKey]; !ok {
-						currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-						timestamp := currentDate.UnixNano() / 1e6
-						timestampStr := fmt.Sprintf("%d", timestamp)
-						val := HbzDiv(currentItem.Value, preItem.Value)
-						if val != "" {
-							addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, val)
-							isAdd = true
-						}
-					}
-					existMap[existKey] = currentItem.DataTime
-				}
-			}
-		}
-		if isAdd {
-			addSql = strings.TrimRight(addSql, ",")
-			_, err = to.Raw(addSql).Exec()
-			if err != nil {
-				return edbInfoId, err
-			}
-		}
-	}
-	return
-}
-
-// 刷新环比值数据
-func RefreshCalculateHbz(edbInfoId, source, subSource int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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)
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 0)
-	if err != nil {
-		return err
-	}
-
-	//获取指标所有数据
-	existDataList := make([]*EdbDataBase, 0)
-	dataTableName := GetEdbDataTableName(source, subSource)
-	fmt.Println("dataTableName:", dataTableName)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
-	if err != nil {
-		return err
-	}
-	existDataMap := make(map[string]string)
-	for _, v := range existDataList {
-		existDataMap[v.DataTime] = v.Value
-	}
-	addSql := ` INSERT INTO edb_data_calculate_hbz(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)
-	fmt.Println("dataLen:", dataLen)
-	for i := 0; i < dataLen; i++ {
-		j := i + 1
-		if j < dataLen {
-			//当期
-			currentItem := dataList[i]
-			preItem := dataList[j]
-			if currentItem != nil && preItem != nil {
-				existKey := edbCode + currentItem.DataTime
-				if _, ok := existMap[existKey]; !ok {
-					currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					val := HbzDiv(currentItem.Value, preItem.Value)
-					if val != "" {
-						if existVal, findOk := existDataMap[currentItem.DataTime]; !findOk {
-							addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, val)
-							isAdd = true
-						} else {
-							if existVal != val {
-								sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-								sql = fmt.Sprintf(sql, dataTableName)
-								_, err = to.Raw(sql, val, edbInfoId, currentItem.DataTime).Exec()
-								if err != nil {
-									return err
-								}
-							}
-						}
-					}
-				}
-				existMap[existKey] = currentItem.DataTime
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}
-
-type EdbInfoCalculateHbzDetail struct {
-	EdbInfoCalculateTbzId int       `orm:"column(edb_info_calculate_tbz_id);pk"`
-	EdbInfoId             int       `description:"指标id"`
-	EdbCode               string    `description:"指标编码"`
-	FromEdbInfoId         int       `description:"计算指标id"`
-	FromEdbCode           string    `description:"计算指标编码"`
-	FromEdbName           string    `description:"计算指标名称"`
-	FromSource            int       `description:"计算指标来源"`
-	FromSourceName        string    `description:"计算指标来源名称"`
-	FromTag               string    `description:"来源指标标签"`
-	Sort                  int       `description:"计算指标名称排序"`
-	CreateTime            time.Time `description:"创建时间"`
-	ModifyTime            time.Time `description:"修改时间"`
-	StartDate             string    `description:"开始日期"`
-	EndDate               string    `description:"结束日期"`
-}
-
-func GetEdbInfoCalculateHbzDetail(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 RefreshAllCalculateHbz(edbInfoId, source, subSource int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string, formulaInt int) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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)
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 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, subSource)
-	fmt.Println("dataTableName:", dataTableName)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
-	if err != nil {
-		return err
-	}
-	existDataMap := make(map[string]string)
-	for _, v := range existDataList {
-		existDataMap[v.DataTime] = v.Value
-	}
-	addSql := ` INSERT INTO edb_data_calculate_hbz(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)
-	fmt.Println("dataLen:", dataLen)
-	for i := 0; i < dataLen; i++ {
-		j := i + formulaInt
-		if j < dataLen {
-			//当期
-			currentItem := dataList[i]
-			preItem := dataList[j]
-			if currentItem != nil && preItem != nil {
-				existKey := edbCode + currentItem.DataTime
-
-				if _, ok := existMap[existKey]; !ok {
-					currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					val := HbzDiv(currentItem.Value, preItem.Value)
-					if val != "" {
-						if existVal, findOk := existDataMap[currentItem.DataTime]; !findOk {
-							addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, val)
-							isAdd = true
-						} else {
-							if existVal != val {
-								sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-								sql = fmt.Sprintf(sql, dataTableName)
-								_, err = to.Raw(sql, val, edbInfoId, currentItem.DataTime).Exec()
-								if err != nil {
-									return err
-								}
-							}
-						}
-					}
-				}
-				existMap[existKey] = currentItem.DataTime
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}

models/data_manage/edb_info_calculate_hcz.go

@@ -1,540 +0,0 @@
-package data_manage
-
-import (
-	"errors"
-	"eta/eta_api/utils"
-	"fmt"
-	"github.com/beego/beego/v2/client/orm"
-	"github.com/shopspring/decimal"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type EdbInfoCalculateHcz struct {
-	EdbInfoCalculateHczId int       `orm:"column(edb_info_calculate_hcz_id);pk"`
-	EdbInfoId             int       `description:"指标id"`
-	EdbCode               string    `description:"指标编码"`
-	FromEdbInfoId         int       `description:"计算指标id"`
-	FromEdbCode           string    `description:"计算指标编码"`
-	FromEdbName           string    `description:"计算指标名称"`
-	FromSource            int       `description:"计算指标来源"`
-	FromSourceName        string    `description:"计算指标来源名称"`
-	FromTag               string    `description:"来源指标标签"`
-	Sort                  int       `description:"计算指标名称排序"`
-	CreateTime            time.Time `description:"创建时间"`
-	ModifyTime            time.Time `description:"修改时间"`
-}
-
-// 环差值
-func AddCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfoId int, err error) {
-	fmt.Println("AddCalculateHcz")
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			fmt.Println("AddCalculateHcz,Err:" + err.Error())
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
-		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_HCZ
-		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
-		newEdbInfoId, tmpErr := to.Insert(edbInfo)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-		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
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-	} else {
-		edbInfoId = req.EdbInfoId
-		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SUB_SOURCE_EDB)
-		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
-		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
-	}
-
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	fmt.Println("edbInfoIdStr:" + edbInfoIdStr)
-	//计算数据
-	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, fromEdbInfo.SubSource, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_hcz(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)
-	fmt.Println("dataLen:", dataLen)
-	for i := 0; i < dataLen; i++ {
-		j := i + formulaInt
-		if j < dataLen {
-			//当期
-			currentItem := dataList[i]
-			preItem := dataList[j]
-			if currentItem != nil && preItem != nil {
-				existKey := edbCode + currentItem.DataTime
-				if _, ok := existMap[existKey]; !ok {
-					currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					val := ""
-					if preItem.Value == 0 {
-						val = "0"
-					} else {
-						val = HczDiv(currentItem.Value, preItem.Value)
-					}
-					if val != "" {
-						addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, val)
-						isAdd = true
-					}
-				}
-				existMap[existKey] = currentItem.DataTime
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
-	return
-}
-
-// 环差值，current:当期,pre:上期 公式:当期-上期
-func HczDiv(current, pre float64) string {
-	if pre == 0 {
-		return ""
-	}
-	currentVal := decimal.NewFromFloat(current)
-	preVal := decimal.NewFromFloat(pre)
-	val, _ := currentVal.Sub(preVal).Float64()
-	valStr := utils.SubFloatToString(val, 4)
-	return valStr
-}
-
-// 环比值
-func EditCalculateHcz(req *EdbInfoCalculateBatchEditReq, fromEdbInfo *EdbInfo, edbCode string, formulaInt int, calculateFormula string) (edbInfoId int, err error) {
-	edbInfoId = req.EdbInfoId
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-
-	//修改指标信息
-	sql := ` UPDATE  edb_info
-			SET
-			  edb_name =?,
-			  edb_name_source=?,
-			  frequency = ?,
-			  unit = ?,
-			  classify_id = ?,
- 			  calculate_formula=?,
-			  modify_time = NOW()
-			WHERE edb_info_id = ? `
-	_, err = to.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, 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 || strconv.Itoa(formulaInt) != calculateFormula {
-		//删除，计算指标关联的，基础指标的关联关系
-		if count <= 0 {
-			sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-			_, err = to.Raw(sql, edbInfoId).Exec()
-			if err != nil {
-				return edbInfoId, err
-			}
-			//关联关系
-			{
-				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_HCZ
-				calculateMappingItem.SourceName = "环差值"
-				_, err = to.Insert(calculateMappingItem)
-				if err != nil {
-					return
-				}
-			}
-		}
-		//清空原有数据
-		sql = ` DELETE FROM edb_data_calculate_hcz WHERE edb_info_id = ? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-		edbInfoIdStr := strconv.Itoa(edbInfoId)
-		fmt.Println("edbInfoIdStr:" + edbInfoIdStr)
-		//计算数据
-		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, fromEdbInfo.SubSource, 0)
-		if err != nil {
-			return edbInfoId, err
-		}
-		var dateArr []string
-		dataMap := make(map[string]*EdbInfoSearchData)
-		for _, v := range dataList {
-			dateArr = append(dateArr, v.DataTime)
-			dataMap[v.DataTime] = v
-		}
-
-		addSql := ` INSERT INTO edb_data_calculate_hcz(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)
-		fmt.Println("dataLen:", dataLen)
-		for i := 0; i < dataLen; i++ {
-			j := i + formulaInt
-			if j < dataLen {
-				//当期
-				currentItem := dataList[i]
-				preItem := dataList[j]
-				if currentItem != nil && preItem != nil {
-					existKey := edbCode + currentItem.DataTime
-					if _, ok := existMap[existKey]; !ok {
-						currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-						timestamp := currentDate.UnixNano() / 1e6
-						timestampStr := fmt.Sprintf("%d", timestamp)
-						val := HczDiv(currentItem.Value, preItem.Value)
-						if val != "" {
-							addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, val)
-							isAdd = true
-						}
-					}
-					existMap[existKey] = currentItem.DataTime
-				}
-			}
-		}
-		if isAdd {
-			addSql = strings.TrimRight(addSql, ",")
-			_, err = to.Raw(addSql).Exec()
-			if err != nil {
-				return edbInfoId, err
-			}
-		}
-	}
-	return
-}
-
-// 刷新环比值数据
-func RefreshCalculateHcz(edbInfoId, source, subSource int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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)
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 0)
-	if err != nil {
-		return err
-	}
-
-	//获取指标所有数据
-	existDataList := make([]*EdbDataBase, 0)
-	dataTableName := GetEdbDataTableName(source, subSource)
-	fmt.Println("dataTableName:", dataTableName)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
-	if err != nil {
-		return err
-	}
-	existDataMap := make(map[string]string)
-	for _, v := range existDataList {
-		existDataMap[v.DataTime] = v.Value
-	}
-	addSql := ` INSERT INTO edb_data_calculate_hcz(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++ {
-		j := i + 1
-		if j < dataLen {
-			//当期
-			currentItem := dataList[i]
-			preItem := dataList[j]
-			if currentItem != nil && preItem != nil {
-				existKey := edbCode + currentItem.DataTime
-				if _, ok := existMap[existKey]; !ok {
-					currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					val := HczDiv(currentItem.Value, preItem.Value)
-					if val != "" {
-						if existVal, findOk := existDataMap[currentItem.DataTime]; !findOk {
-							addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, val)
-							isAdd = true
-						} else {
-							if existVal != val {
-								sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-								sql = fmt.Sprintf(sql, dataTableName)
-								_, err = to.Raw(sql, val, edbInfoId, currentItem.DataTime).Exec()
-								if err != nil {
-									return err
-								}
-							}
-						}
-					}
-				}
-				existMap[existKey] = currentItem.DataTime
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}
-
-type EdbInfoCalculateHczDetail struct {
-	EdbInfoCalculateHczId int       `orm:"column(edb_info_calculate_hcz_id);pk"`
-	EdbInfoId             int       `description:"指标id"`
-	EdbCode               string    `description:"指标编码"`
-	FromEdbInfoId         int       `description:"计算指标id"`
-	FromEdbCode           string    `description:"计算指标编码"`
-	FromEdbName           string    `description:"计算指标名称"`
-	FromSource            int       `description:"计算指标来源"`
-	FromSourceName        string    `description:"计算指标来源名称"`
-	FromTag               string    `description:"来源指标标签"`
-	Sort                  int       `description:"计算指标名称排序"`
-	CreateTime            time.Time `description:"创建时间"`
-	ModifyTime            time.Time `description:"修改时间"`
-	StartDate             string    `description:"开始日期"`
-	EndDate               string    `description:"结束日期"`
-}
-
-func GetEdbInfoCalculateHczDetail(edbInfoId int) (item *EdbInfoCalculateHczDetail, 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 RefreshAllCalculateHcz(edbInfoId, source, subSource int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string, formulaInt int) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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)
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 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, subSource)
-	fmt.Println("dataTableName:", dataTableName)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = to.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_hcz(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)
-	fmt.Println("dataLen:", dataLen)
-	for i := 0; i < dataLen; i++ {
-		j := i + formulaInt
-		if j < dataLen {
-			//当期
-			currentItem := dataList[i]
-			preItem := dataList[j]
-			if currentItem != nil && preItem != nil {
-				existKey := edbCode + currentItem.DataTime
-				if _, ok := existMap[existKey]; !ok {
-					currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					val := HczDiv(currentItem.Value, preItem.Value)
-					if val != "" {
-						if existVal, findOk := existDataMap[currentItem.DataTime]; !findOk {
-							addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, val)
-							isAdd = true
-						} else {
-							if existVal != val {
-								sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-								sql = fmt.Sprintf(sql, dataTableName)
-								_, err = to.Raw(sql, val, edbInfoId, currentItem.DataTime).Exec()
-								if err != nil {
-									return err
-								}
-							}
-						}
-					}
-				}
-				existMap[existKey] = currentItem.DataTime
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}

models/data_manage/edb_info_calculate_ljztbpj.go

@@ -1,650 +0,0 @@
-package data_manage
-
-import (
-	"errors"
-	"eta/eta_api/utils"
-	"fmt"
-	"github.com/beego/beego/v2/client/orm"
-	"github.com/shopspring/decimal"
-	"sort"
-	"strings"
-	"time"
-)
-
-// AddCalculateLjztbpj 新增累计值同比拼接数据
-func AddCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
-	fmt.Println("AddCalculateLjztbpj")
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			fmt.Println("AddCalculateLjztbpj,Err:" + err.Error())
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-	//待拼接指标map
-	pjDataMap := make(map[string]float64)
-
-	//拼接指标的日期切片数据
-	pjEdbDataTimeList := make([]string, 0)
-
-	//最近开始的时间
-	var lastDateTime time.Time
-	//获取待拼接指标
-	{
-		var condition string
-		var pars []interface{}
-
-		//获取待拼接指标最近的个12月31日有值的年份
-		condition += " AND data_time like ? AND edb_info_id=? "
-		pars = append(pars, "%12-31", firstEdbInfo.EdbInfoId)
-
-		lastEdbData, tmpErr := GetLastEdbData(condition, pars, firstEdbInfo.Source, firstEdbInfo.SubSource)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-		lastDateTime, _ = time.ParseInLocation(utils.FormatDate, lastEdbData.DataTime, time.Local)
-
-		//获取待拼接指标的数据列表
-		condition = ``
-		pars = make([]interface{}, 0)
-		condition += " AND data_time <= ? AND edb_info_id=? "
-		pars = append(pars, lastEdbData.DataTime, firstEdbInfo.EdbInfoId)
-
-		firstDataList, tmpErr := GetEdbDataListAll(condition, pars, firstEdbInfo.Source, firstEdbInfo.SubSource, 0)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-
-		for _, v := range firstDataList {
-			pjDataMap[v.DataTime] = v.Value
-			pjEdbDataTimeList = append(pjEdbDataTimeList, v.DataTime)
-		}
-	}
-
-	var edbInfo *EdbInfo
-	if req.EdbInfoId <= 0 {
-		edbInfo = &EdbInfo{
-			SourceName:       "累计值同比拼接",
-			Source:           utils.DATA_SOURCE_CALCULATE_LJZTBPJ,
-			EdbCode:          edbCode,
-			EdbName:          req.EdbName,
-			EdbNameSource:    req.EdbName,
-			Frequency:        req.Frequency,
-			Unit:             req.Unit,
-			StartDate:        firstEdbInfo.StartDate,
-			EndDate:          firstEdbInfo.EndDate,
-			ClassifyId:       req.ClassifyId,
-			SysUserId:        sysUserId,
-			SysUserRealName:  sysUserRealName,
-			UniqueCode:       uniqueCode,
-			CreateTime:       time.Now(),
-			ModifyTime:       time.Now(),
-			CalculateFormula: lastDateTime.Format(utils.FormatDate),
-			EdbType:          2,
-		}
-		newEdbInfoId, err := to.Insert(edbInfo)
-		if err != nil {
-			return edbInfoId, err
-		}
-		edbInfoId = int(newEdbInfoId)
-	} else {
-		edbInfoId = req.EdbInfoId
-		//查询
-		tmpEdbInfo, tmpErr := GetEdbInfoById(edbInfoId)
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
-		tmpEdbInfo.EdbName = req.EdbName
-		tmpEdbInfo.ClassifyId = req.ClassifyId
-		tmpEdbInfo.Frequency = req.Frequency
-		tmpEdbInfo.Unit = req.Unit
-		tmpEdbInfo.CalculateFormula = req.Formula
-
-		edbInfo = tmpEdbInfo
-
-		//删除指标数据
-		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_LJZTBPJ, utils.DATA_SUB_SOURCE_EDB)
-		fmt.Println("dataTableName:" + dataTableName)
-		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
-		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
-		if err != nil {
-			return 0, err
-		}
-
-		//删除指标关系
-		sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id=? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-	}
-
-	//关联关系
-
-	//拼接指标
-	{
-		calculateMappingItem := new(EdbInfoCalculateMapping)
-		calculateMappingItem.CreateTime = time.Now()
-		calculateMappingItem.ModifyTime = time.Now()
-		calculateMappingItem.Sort = 1
-		calculateMappingItem.EdbCode = edbCode
-		calculateMappingItem.EdbInfoId = edbInfoId
-		calculateMappingItem.FromEdbInfoId = firstEdbInfo.EdbInfoId
-		calculateMappingItem.FromEdbCode = firstEdbInfo.EdbCode
-		calculateMappingItem.FromEdbName = firstEdbInfo.EdbName
-		calculateMappingItem.FromSource = firstEdbInfo.Source
-		calculateMappingItem.FromSourceName = firstEdbInfo.SourceName
-		calculateMappingItem.FromTag = "A"
-		calculateMappingItem.Source = edbInfo.Source
-		calculateMappingItem.SourceName = edbInfo.SourceName
-		_, err = to.Insert(calculateMappingItem)
-		if err != nil {
-			return
-		}
-	}
-
-	//同比值指标
-	{
-		calculateMappingItem := new(EdbInfoCalculateMapping)
-		calculateMappingItem.CreateTime = time.Now()
-		calculateMappingItem.ModifyTime = time.Now()
-		calculateMappingItem.Sort = 1
-		calculateMappingItem.EdbCode = edbCode
-		calculateMappingItem.EdbInfoId = edbInfoId
-		calculateMappingItem.FromEdbInfoId = secondEdbInfo.EdbInfoId
-		calculateMappingItem.FromEdbCode = secondEdbInfo.EdbCode
-		calculateMappingItem.FromEdbName = secondEdbInfo.EdbName
-		calculateMappingItem.FromSource = secondEdbInfo.Source
-		calculateMappingItem.FromSourceName = secondEdbInfo.SourceName
-		calculateMappingItem.FromTag = "B"
-		calculateMappingItem.Source = edbInfo.Source
-		calculateMappingItem.SourceName = edbInfo.SourceName
-		_, err = to.Insert(calculateMappingItem)
-		if err != nil {
-			return
-		}
-	}
-
-	//同比值指标map
-	tbzEdbDataMap := make(map[string]float64)
-
-	//同比值日期切片列表
-	tbzEdbDataTimeList := make([]string, 0)
-
-	//同比值指标
-	{
-		var condition string
-		var pars []interface{}
-
-		condition += " AND data_time > ? AND edb_info_id = ? "
-		pars = append(pars, lastDateTime, secondEdbInfo.EdbInfoId)
-
-		//同比值指标的数据列表
-		secondDataList, tmpErr := GetEdbDataListAll(condition, pars, secondEdbInfo.Source, secondEdbInfo.SubSource, 0)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-
-		for _, v := range secondDataList {
-			tbzEdbDataMap[v.DataTime] = v.Value
-			tbzEdbDataTimeList = append(tbzEdbDataTimeList, v.DataTime)
-		}
-	}
-
-	sort.Strings(tbzEdbDataTimeList)
-	for _, v := range tbzEdbDataTimeList {
-		tbzDataTime, _ := time.ParseInLocation(utils.FormatDate, v, time.Local)
-
-		//获取拼接指标上一年同一天的数据
-		var pjDataTime time.Time
-		if tbzDataTime.Month() == 2 {
-			pjDataTime = tbzDataTime.AddDate(0, -11, 0)
-			pjDataTime = time.Date(pjDataTime.Year(), pjDataTime.Month(), 1, 0, 0, 0, 0, time.Now().Location()).AddDate(0, 0, -1)
-		} else {
-			pjDataTime = tbzDataTime.AddDate(-1, 0, 0)
-		}
-
-		//如果存在数据，那么就去计算当前的数据
-		if pjDataValue, ok := pjDataMap[pjDataTime.Format(utils.FormatDate)]; ok {
-			tbzDataValue := tbzEdbDataMap[v] //同比值
-			currValue := pjDataValue * (1 + tbzDataValue/100)
-
-			currValue, _ = decimal.NewFromFloat(currValue).Truncate(4).Float64()
-			//将计算后的数据存入待拼接指标map里面，以便后续计算
-			pjDataMap[v] = currValue
-
-			pjEdbDataTimeList = append(pjEdbDataTimeList, v)
-		}
-	}
-
-	addDataList := make([]*EdbDataCalculateLjztbpj, 0)
-
-	//日期排序下
-	sort.Strings(pjEdbDataTimeList)
-	//这么做的目的是为了让数据插入的时候，可以正序插入（业务上没啥卵用，就是为了让我看数据的时候舒服点，手动狗头-_-|）
-	for _, dataTime := range pjEdbDataTimeList {
-		if dataValue, ok := pjDataMap[dataTime]; ok {
-			//时间戳
-			currentDate, _ := time.Parse(utils.FormatDate, dataTime)
-			timestamp := currentDate.UnixNano() / 1e6
-
-			edbDataLjztbpj := &EdbDataCalculateLjztbpj{
-				EdbInfoId:     edbInfoId,
-				EdbCode:       edbInfo.EdbCode,
-				DataTime:      dataTime,
-				Value:         dataValue,
-				Status:        1,
-				CreateTime:    time.Now(),
-				ModifyTime:    time.Now(),
-				DataTimestamp: timestamp,
-			}
-			addDataList = append(addDataList, edbDataLjztbpj)
-		}
-	}
-
-	//数据入库
-	tmpAddDataList := make([]*EdbDataCalculateLjztbpj, 0)
-	for _, v := range addDataList {
-		tmpAddDataList = append(tmpAddDataList, v)
-
-		if len(tmpAddDataList) >= 200 {
-			_, tmpErr := to.InsertMulti(len(tmpAddDataList), tmpAddDataList)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-			//重新初始化需要加入的数据切片
-			tmpAddDataList = make([]*EdbDataCalculateLjztbpj, 0)
-		}
-	}
-	//最后如果还有需要新增的数据，那么就统一入库
-	if len(tmpAddDataList) > 0 {
-		_, tmpErr := to.InsertMulti(len(tmpAddDataList), tmpAddDataList)
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
-	}
-
-	return
-}
-
-// EditCalculateLjztbpj 编辑累计值同比拼接数据
-func EditCalculateLjztbpj(req *EdbInfoCalculateBatchEditReq, nowEdbInfo, firstEdbInfo, secondEdbInfo *EdbInfo) (edbInfoId int, err error) {
-	edbInfoId = req.EdbInfoId
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-
-	sql := ``
-
-	var existCondition string
-	var existPars []interface{}
-	existCondition += " AND edb_info_id=? "
-	existPars = append(existPars, edbInfoId)
-
-	//查询出所有的关联指标
-	existList, err := GetEdbInfoCalculateListByCondition(existCondition, existPars)
-	if err != nil {
-		err = errors.New("判断指标是否改变失败,Err:" + err.Error())
-		return
-	}
-
-	var existItemA, existItemB *EdbInfoCalculateMapping
-	for _, existItem := range existList {
-		if existItem.FromTag == "A" {
-			existItemA = existItem
-		} else if existItem.FromTag == "B" {
-			existItemB = existItem
-		}
-	}
-	// 原数据开始计算日期
-	startCalculationDate, _ := time.ParseInLocation(utils.FormatDate, nowEdbInfo.CalculateFormula, time.Local)
-
-	//待拼接指标map
-	pjDataMap := make(map[string]float64)     //需要入库的数据
-	nowEdbDataMap := make(map[string]float64) //当前指标的数据（已经在库里了，不需要重新）
-
-	//拼接指标的日期切片数据
-	pjEdbDataTimeList := make([]string, 0)
-
-	//最近开始的时间
-	lastDateTime := startCalculationDate
-
-	//待拼接指标数据
-	{
-		//如果拼接指标变更了，那么需要删除所有的指标进行重新拼接
-		if existItemA.FromEdbInfoId != firstEdbInfo.EdbInfoId {
-			//删除旧的指标数据
-			{
-				//删除之前的A指标关联关系
-				sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? and from_edb_info_id = ?`
-				_, err = to.Raw(sql, edbInfoId, existItemA.FromEdbInfoId).Exec()
-				if err != nil {
-					err = errors.New("删除拼接日期之前的指标关联关系失败,Err:" + err.Error())
-					return
-				}
-
-				//如果拼接指标变更了，那么需要删除所有的指标数据
-				tableName := GetEdbDataTableName(nowEdbInfo.Source, nowEdbInfo.SubSource)
-				sql = fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? `, tableName)
-
-				_, err = to.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 = nowEdbInfo.EdbCode
-				calculateMappingItem.EdbInfoId = edbInfoId
-				calculateMappingItem.FromEdbInfoId = firstEdbInfo.EdbInfoId
-				calculateMappingItem.FromEdbCode = firstEdbInfo.EdbCode
-				calculateMappingItem.FromEdbName = firstEdbInfo.EdbName
-				calculateMappingItem.FromSource = firstEdbInfo.Source
-				calculateMappingItem.FromSourceName = firstEdbInfo.SourceName
-				calculateMappingItem.FromTag = "A"
-				calculateMappingItem.Source = nowEdbInfo.Source
-				calculateMappingItem.SourceName = nowEdbInfo.SourceName
-				_, err = to.Insert(calculateMappingItem)
-				if err != nil {
-					return
-				}
-			}
-
-			var condition string
-			var pars []interface{}
-
-			//获取待拼接指标最近的个12月31日有值的年份
-			condition += " AND data_time like ? AND edb_info_id=? "
-			pars = append(pars, "%12-31", firstEdbInfo.EdbInfoId)
-
-			//获取最新的待拼接指标
-			lastEdbData, tmpErr := GetLastEdbData(condition, pars, firstEdbInfo.Source, firstEdbInfo.SubSource)
-			if tmpErr != nil {
-				return edbInfoId, tmpErr
-			}
-			lastDateTime, _ = time.ParseInLocation(utils.FormatDate, lastEdbData.DataTime, time.Local)
-
-			//获取待拼接指标的数据列表
-			condition = ``
-			pars = make([]interface{}, 0)
-			condition += " AND data_time <= ? AND edb_info_id=? "
-			pars = append(pars, lastEdbData.DataTime, firstEdbInfo.EdbInfoId)
-
-			firstDataList, tmpErr := GetEdbDataListAll(condition, pars, firstEdbInfo.Source, firstEdbInfo.SubSource, 0)
-			if tmpErr != nil {
-				return edbInfoId, tmpErr
-			}
-
-			for _, v := range firstDataList {
-				pjDataMap[v.DataTime] = v.Value
-				pjEdbDataTimeList = append(pjEdbDataTimeList, v.DataTime)
-
-				//将新的数据存入已入库指标map里面，以便后续计算
-				nowEdbDataMap[v.DataTime] = v.Value
-			}
-		} else {
-			// 获取当前指标的所有数据
-			var condition string
-			var pars []interface{}
-			condition += " AND edb_info_id=? and data_time <= ?"
-			pars = append(pars, nowEdbInfo.EdbInfoId, nowEdbInfo.CalculateFormula)
-
-			nowEdbDataList, tmpErr := GetEdbDataListAll(condition, pars, nowEdbInfo.Source, nowEdbInfo.SubSource, 0)
-			if tmpErr != nil {
-				return edbInfoId, tmpErr
-			}
-
-			for _, v := range nowEdbDataList {
-				nowEdbDataMap[v.DataTime] = v.Value
-				pjEdbDataTimeList = append(pjEdbDataTimeList, v.DataTime)
-			}
-		}
-	}
-
-	//同比值指标map
-	tbzEdbDataMap := make(map[string]float64)
-
-	//同比值日期切片列表
-	tbzEdbDataTimeList := make([]string, 0)
-
-	//同比值指标
-	{
-		if existItemB.FromEdbInfoId != secondEdbInfo.EdbInfoId {
-			//删除通过B指标生成的数据
-			{
-				//删除之前的B指标关联关系
-				sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? and from_edb_info_id = ?`
-				_, err = to.Raw(sql, edbInfoId, existItemB.FromEdbInfoId).Exec()
-				if err != nil {
-					err = errors.New("删除拼接日期之后的指标关联关系失败,Err:" + err.Error())
-					return
-				}
-
-				//如果同比值指标变更了，那么需要删除所有计算出来的指标数据
-				tableName := GetEdbDataTableName(nowEdbInfo.Source, nowEdbInfo.SubSource)
-				sql = fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? and data_time > ? `, tableName)
-
-				_, err = to.Raw(sql, edbInfoId, nowEdbInfo.CalculateFormula).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 = nowEdbInfo.EdbCode
-				calculateMappingItem.EdbInfoId = edbInfoId
-				calculateMappingItem.FromEdbInfoId = secondEdbInfo.EdbInfoId
-				calculateMappingItem.FromEdbCode = secondEdbInfo.EdbCode
-				calculateMappingItem.FromEdbName = secondEdbInfo.EdbName
-				calculateMappingItem.FromSource = secondEdbInfo.Source
-				calculateMappingItem.FromSourceName = secondEdbInfo.SourceName
-				calculateMappingItem.FromTag = "B"
-				calculateMappingItem.Source = nowEdbInfo.Source
-				calculateMappingItem.SourceName = nowEdbInfo.SourceName
-				_, err = to.Insert(calculateMappingItem)
-				if err != nil {
-					return
-				}
-			}
-		}
-
-		var condition string
-		var pars []interface{}
-
-		condition += " AND data_time > ? AND edb_info_id = ? "
-		pars = append(pars, lastDateTime, secondEdbInfo.EdbInfoId)
-
-		//同比值指标的数据列表
-		secondDataList, tmpErr := GetEdbDataListAll(condition, pars, secondEdbInfo.Source, secondEdbInfo.SubSource, 0)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-
-		for _, v := range secondDataList {
-			tbzEdbDataMap[v.DataTime] = v.Value
-			tbzEdbDataTimeList = append(tbzEdbDataTimeList, v.DataTime)
-		}
-	}
-
-	sort.Strings(tbzEdbDataTimeList)
-
-	// 遍历现有的数据，判断拼接指标中是否存在该日期数据，如果拼接指标无此数据，那么需要删除该日期数据（日期的判断：需要在开始计算日期之后）
-	removeDateList := make([]string, 0)
-	for nowEdbDate := range nowEdbDataMap {
-		nowEdbDateTime, _ := time.ParseInLocation(utils.FormatDate, nowEdbDate, time.Local)
-		//校验日期 需要 大于 拼接前日期
-		if startCalculationDate.Before(nowEdbDateTime) {
-			if _, ok := tbzEdbDataMap[nowEdbDate]; !ok {
-				// 同比指标中，不存在该日期数据，那么需要移除 现有数据 中该日期的数据
-				removeDateList = append(removeDateList, nowEdbDate)
-			}
-		}
-	}
-
-	//待修改的指标数据map（index：日期，value：值）
-	updateEdbDataMap := make(map[string]float64)
-	for _, v := range tbzEdbDataTimeList {
-		tbzDataTime, _ := time.ParseInLocation(utils.FormatDate, v, time.Local)
-
-		//获取拼接指标上一年同一天的数据
-		var pjDataTime time.Time
-		if tbzDataTime.Month() == 2 {
-			pjDataTime = tbzDataTime.AddDate(0, -11, 0)
-			pjDataTime = time.Date(pjDataTime.Year(), pjDataTime.Month(), 1, 0, 0, 0, 0, time.Now().Location()).AddDate(0, 0, -1)
-		} else {
-			pjDataTime = tbzDataTime.AddDate(-1, 0, 0)
-		}
-
-		//校验现有数据中，是否存在该日期的数据，如果存在的话，那么就要去校验 最新计算数据 与 现有数据 是否一致
-		if nowEdbDataValue, isHas := nowEdbDataMap[v]; isHas {
-			//获取去年今日的数据，获取到后，然后是去修改该日期的数据
-			if lastYearEdbDataValue, ok := nowEdbDataMap[pjDataTime.Format(utils.FormatDate)]; ok {
-				tbzDataValue := tbzEdbDataMap[v] //同比值
-				currValue := lastYearEdbDataValue * (1 + tbzDataValue/100)
-				currValue, _ = decimal.NewFromFloat(currValue).Truncate(4).Float64() //保留4位小数
-				//如果计算出来的值与库里面的值不匹配，那么就去修改该值
-				if nowEdbDataValue != currValue {
-					//将计算后的数据存入待拼接指标map里面，以便后续计算
-					updateEdbDataMap[v] = currValue
-				}
-			}
-		} else {
-			//因为 现有数据中 不存在该日期数据，那么需要做新增数据处理
-
-			//如果去年今日存在该数据，那么就去计算当前的数据
-			if pjDataValue, ok := nowEdbDataMap[pjDataTime.Format(utils.FormatDate)]; ok {
-				tbzDataValue := tbzEdbDataMap[v] //同比值
-				currValue := pjDataValue * (1 + tbzDataValue/100)
-
-				currValue, _ = decimal.NewFromFloat(currValue).Truncate(4).Float64()
-				//将计算后的数据存入已入库指标map里面，以便后续计算
-				nowEdbDataMap[v] = currValue
-
-				//将计算后的数据存入待拼接指标map里面，以便后续入库
-				pjDataMap[v] = currValue
-				pjEdbDataTimeList = append(pjEdbDataTimeList, v)
-			}
-		}
-	}
-
-	//新增的数据入库
-	{
-		addDataList := make([]*EdbDataCalculateLjztbpj, 0)
-		for dataTime, dataValue := range pjDataMap {
-			//时间戳
-			currentDate, _ := time.Parse(utils.FormatDate, dataTime)
-			timestamp := currentDate.UnixNano() / 1e6
-
-			edbDataLjztbpj := &EdbDataCalculateLjztbpj{
-				EdbInfoId:     edbInfoId,
-				EdbCode:       nowEdbInfo.EdbCode,
-				DataTime:      dataTime,
-				Value:         dataValue,
-				Status:        1,
-				CreateTime:    time.Now(),
-				ModifyTime:    time.Now(),
-				DataTimestamp: timestamp,
-			}
-			addDataList = append(addDataList, edbDataLjztbpj)
-		}
-
-		tmpAddDataList := make([]*EdbDataCalculateLjztbpj, 0)
-		for _, v := range addDataList {
-			tmpAddDataList = append(tmpAddDataList, v)
-
-			if len(tmpAddDataList) >= 200 {
-				_, tmpErr := to.InsertMulti(len(tmpAddDataList), tmpAddDataList)
-				if tmpErr != nil {
-					err = tmpErr
-					return
-				}
-				//重新初始化需要加入的数据切片
-				tmpAddDataList = make([]*EdbDataCalculateLjztbpj, 0)
-			}
-		}
-		//最后如果还有需要新增的数据，那么就统一入库
-		if len(tmpAddDataList) > 0 {
-			_, tmpErr := to.InsertMulti(len(tmpAddDataList), tmpAddDataList)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-		}
-	}
-
-	//删除已经不存在的累计同比拼接指标数据（由于同比值当日的数据删除了）
-	{
-		if len(removeDateList) > 0 {
-			removeDateStr := strings.Join(removeDateList, `","`)
-			removeDateStr = `"` + removeDateStr + `"`
-			//如果拼接指标变更了，那么需要删除所有的指标数据
-			tableName := GetEdbDataTableName(nowEdbInfo.Source, nowEdbInfo.SubSource)
-			sql = fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? and data_time in (%s) `, tableName, removeDateStr)
-
-			_, err = to.Raw(sql, edbInfoId).Exec()
-			if err != nil {
-				err = errors.New("删除不存在的累计值同比拼接指标数据失败,Err:" + err.Error())
-				return
-			}
-		}
-	}
-
-	//修改现有的数据中对应的值
-	{
-		tableName := GetEdbDataTableName(nowEdbInfo.Source, nowEdbInfo.SubSource)
-		for edbDate, edbDataValue := range updateEdbDataMap {
-			sql = fmt.Sprintf(` UPDATE  %s set value = %f,modify_time=now() WHERE edb_info_id = ? and data_time = %s `, tableName, edbDataValue, edbDate)
-
-			_, err = to.Raw(sql, edbInfoId).Exec()
-			if err != nil {
-				err = errors.New("更新现有的累计值同比拼接指标数据失败,Err:" + err.Error())
-				return
-			}
-		}
-	}
-
-	//修改指标信息
-	sql = ` UPDATE  edb_info SET
-			  edb_name =?,
-			  edb_name_source=?,
-			  frequency = ?,
-			  unit = ?,
-			  classify_id = ?, 
-			  calculate_formula=?,
-			  modify_time = NOW()
-			WHERE edb_info_id = ? `
-	_, err = to.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, lastDateTime.Format(utils.FormatDate), edbInfoId).Exec()
-	if err != nil {
-		return
-	}
-
-	return
-}

models/data_manage/edb_info_calculate_ljzzy.go

@@ -1,798 +0,0 @@
-package data_manage
-
-import (
-	"errors"
-	"eta/eta_api/utils"
-	"fmt"
-	"github.com/beego/beego/v2/client/orm"
-	"github.com/shopspring/decimal"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type EdbInfoCalculateLjzzy struct {
-	EdbInfoCalculateLjzzyId int       `orm:"column(edb_info_calculate_ljzzy_id);pk"`
-	EdbInfoId               int       `description:"指标id"`
-	EdbCode                 string    `description:"指标编码"`
-	FromEdbInfoId           int       `description:"计算指标id"`
-	FromEdbCode             string    `description:"计算指标编码"`
-	FromEdbName             string    `description:"计算指标名称"`
-	FromSource              int       `description:"计算指标来源"`
-	FromSourceName          string    `description:"计算指标来源名称"`
-	FromTag                 string    `description:"来源指标标签"`
-	Sort                    int       `description:"计算指标名称排序"`
-	CreateTime              time.Time `description:"创建时间"`
-	ModifyTime              time.Time `description:"修改时间"`
-}
-
-func AddEdbInfoCalculateLjzzyMulti(items []*EdbInfoCalculateLjzzy) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(1, items)
-	return
-}
-
-// 累计值转月
-func AddCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-
-	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
-		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_LJZZY
-		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
-		newEdbInfoId, tmpErr := to.Insert(edbInfo)
-		if tmpErr != nil {
-			return int(newEdbInfoId), tmpErr
-		}
-		edbInfoId = int(newEdbInfoId)
-
-		//calculateItem := new(EdbInfoCalculateLjzzy)
-		//calculateItem.CreateTime = time.Now()
-		//calculateItem.ModifyTime = time.Now()
-		//calculateItem.Sort = 1
-		//calculateItem.EdbCode = edbCode
-		//calculateItem.EdbInfoId = edbInfoId
-		//calculateItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
-		//calculateItem.FromEdbCode = fromEdbInfo.EdbCode
-		//calculateItem.FromEdbName = fromEdbInfo.EdbName
-		//calculateItem.FromSource = fromEdbInfo.Source
-		//calculateItem.FromSourceName = fromEdbInfo.SourceName
-		//_, err = to.Insert(calculateItem)
-		//if err != nil {
-		//	return edbInfoId, err
-		//}
-		//关联关系
-		{
-			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
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-	} else {
-		edbInfoId = req.EdbInfoId
-		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_LJZZY, utils.DATA_SUB_SOURCE_EDB)
-		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
-		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
-	}
-	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)
-	}
-	fmt.Println("EdbInfoId:", req.FromEdbInfoId)
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 1)
-	if err != nil {
-		return edbInfoId, err
-	}
-
-	yearMap := make(map[int]map[int]*EdbInfoSearchData)
-	dataLen := len(dataList)
-	for i := 0; i < dataLen; i++ {
-		item := dataList[i]
-		//日其中获取年
-		itemDate, err := time.Parse(utils.FormatDate, item.DataTime)
-		if err != nil {
-			return edbInfoId, err
-		}
-		year := itemDate.Year()
-		month := int(itemDate.Month())
-		if monthMap, yok := yearMap[year]; yok {
-			monthMap[month] = item
-			yearMap[year] = monthMap
-		} else {
-			monthMap = make(map[int]*EdbInfoSearchData)
-			monthMap[month] = item
-			yearMap[year] = monthMap
-		}
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_ljzzy(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	for yk, yv := range yearMap {
-		_, oneMonthOk := yv[1]
-		_, twoMonthOk := yv[2]
-		if !oneMonthOk && !twoMonthOk {
-			continue
-		}
-		for i := 1; i <= 12; i++ {
-			fmt.Println(yk, i, yv[i])
-			dataCurrentItem := yv[i]
-			fmt.Println("i:", i, yk, dataCurrentItem)
-			var date string
-			var val float64
-			if i == 1 || i == 2 {
-				if _, mok := yv[1]; mok { //1月有值
-					if i == 1 {
-						date = dataCurrentItem.DataTime
-						val, _ = decimal.NewFromFloat(dataCurrentItem.Value).Float64() //a.Div(b).Float64()
-					}
-					if i == 2 {
-						dataOneItem := yv[1]
-						if dataCurrentItem != nil {
-							date = dataCurrentItem.DataTime
-							twoMonth := decimal.NewFromFloat(dataCurrentItem.Value)
-							oneMonth := decimal.NewFromFloat(dataOneItem.Value)
-							val, _ = twoMonth.Sub(oneMonth).Float64()
-						} else {
-							continue
-						}
-					}
-				} else { //1月无值
-					dataTwoItem := yv[2]
-					if i == 1 {
-						date = strconv.Itoa(yk) + "-01-31"
-						a := decimal.NewFromFloat(dataTwoItem.Value)
-						b := decimal.NewFromFloat(2.0)
-						val, _ = a.Div(b).Float64()
-					}
-					if i == 2 {
-						date = dataCurrentItem.DataTime
-						a := decimal.NewFromFloat(dataTwoItem.Value)
-						b := decimal.NewFromFloat(2.0)
-						val, _ = a.Div(b).Float64()
-					}
-				}
-			} else {
-				dataPreItem := yv[i-1]
-				if dataCurrentItem != nil && dataPreItem != nil {
-					date = dataCurrentItem.DataTime
-					//val, _ = decimal.NewFromFloat(dataCurrentItem.Value).Sub(decimal.NewFromFloat(dataPreItem.Value)).Float64()
-					a := decimal.NewFromFloat(dataCurrentItem.Value)
-					b := decimal.NewFromFloat(dataPreItem.Value)
-					val, _ = a.Sub(b).Float64()
-				}
-			}
-
-			if date != "" {
-				dataTime, _ := time.Parse(utils.FormatDate, date)
-				timestamp := dataTime.UnixNano() / 1e6
-				timeStr := fmt.Sprintf("%d", timestamp)
-
-				if _, ok := existMap[edbCode+date]; !ok {
-					addSql += GetAddSql(edbInfoIdStr, edbCode, date, timeStr, utils.SubFloatToString(val, 4))
-					isAdd = true
-				}
-				existMap[edbCode+date] = date
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
-	return
-}
-
-// 修改累计值转月
-func EditCalculateLjzzy(req *EdbInfoCalculateBatchEditReq, fromEdbInfo *EdbInfo, edbCode string) (edbInfoId int, err error) {
-	edbInfoId = req.EdbInfoId
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-
-	//修改指标信息
-	sql := ` UPDATE  edb_info
-			SET
-			  edb_name =?,
-              edb_name_source=?,
-			  frequency = ?,
-			  unit = ?,
-			  classify_id = ?,
-			  modify_time = NOW()
-			WHERE edb_info_id = ? `
-	_, err = to.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, 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 {
-		//删除指标关联计算指标
-		//sql := ` DELETE FROM edb_info_calculate_ljzzy WHERE edb_info_id = ? `
-		//_, err = to.Raw(sql, edbInfoId).Exec()
-		//if err != nil {
-		//	return
-		//}
-
-		//calculateItem := new(EdbInfoCalculateLjzzy)
-		//calculateItem.CreateTime = time.Now()
-		//calculateItem.ModifyTime = time.Now()
-		//calculateItem.Sort = 1
-		//calculateItem.EdbCode = edbCode
-		//calculateItem.EdbInfoId = edbInfoId
-		//calculateItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
-		//calculateItem.FromEdbCode = fromEdbInfo.EdbCode
-		//calculateItem.FromEdbName = fromEdbInfo.EdbName
-		//calculateItem.FromSource = fromEdbInfo.Source
-		//calculateItem.FromSourceName = fromEdbInfo.SourceName
-		//_, err = to.Insert(calculateItem)
-		//if err != nil {
-		//	return
-		//}
-
-		//删除，计算指标关联的，基础指标的关联关系
-		sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			return
-		}
-
-		//清空原有数据
-		sql = ` DELETE FROM edb_data_calculate_ljzzy WHERE edb_info_id = ? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-
-		//关联关系
-		{
-			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_LJZZY
-			calculateMappingItem.SourceName = "累计值转月"
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-
-		//计算数据
-		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, fromEdbInfo.SubSource, 1)
-		if err != nil {
-			return edbInfoId, err
-		}
-
-		yearMap := make(map[int]map[int]*EdbInfoSearchData)
-		dataLen := len(dataList)
-		for i := 0; i < dataLen; i++ {
-			item := dataList[i]
-			//日其中获取年
-			itemDate, err := time.Parse(utils.FormatDate, item.DataTime)
-			if err != nil {
-				return edbInfoId, err
-			}
-			year := itemDate.Year()
-			month := int(itemDate.Month())
-			if monthMap, yok := yearMap[year]; yok {
-				monthMap[month] = item
-				yearMap[year] = monthMap
-			} else {
-				monthMap = make(map[int]*EdbInfoSearchData)
-				monthMap[month] = item
-				yearMap[year] = monthMap
-			}
-		}
-
-		addSql := ` INSERT INTO edb_data_calculate_ljzzy(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-		nowStr := time.Now().Format(utils.FormatDateTime)
-		var isAdd bool
-
-		for yk, yv := range yearMap {
-			_, oneMonthOk := yv[1]
-			_, twoMonthOk := yv[2]
-			if !oneMonthOk && !twoMonthOk {
-				continue
-			}
-			for i := 1; i <= 12; i++ {
-				fmt.Println(yk, i, yv[i])
-				dataCurrentItem := yv[i]
-				var date string
-				var val float64
-				if i == 1 || i == 2 {
-					if _, mok := yv[1]; mok { //1月有值
-						if i == 1 {
-							date = dataCurrentItem.DataTime
-							val, _ = decimal.NewFromFloat(dataCurrentItem.Value).Float64() //a.Div(b).Float64()
-						}
-						if i == 2 {
-							dataOneItem := yv[1]
-							date = dataCurrentItem.DataTime
-							twoMonth := decimal.NewFromFloat(dataCurrentItem.Value)
-							oneMonth := decimal.NewFromFloat(dataOneItem.Value)
-							val, _ = twoMonth.Sub(oneMonth).Float64()
-						}
-					} else { //1月无值
-						dataTwoItem := yv[2]
-						if i == 1 {
-							date = strconv.Itoa(yk) + "-01-31"
-							a := decimal.NewFromFloat(dataTwoItem.Value)
-							b := decimal.NewFromFloat(2.0)
-							val, _ = a.Div(b).Float64()
-						}
-						if i == 2 {
-							date = dataCurrentItem.DataTime
-							a := decimal.NewFromFloat(dataTwoItem.Value)
-							b := decimal.NewFromFloat(2.0)
-							val, _ = a.Div(b).Float64()
-						}
-					}
-				} else {
-					dataPreItem := yv[i-1]
-					if dataCurrentItem != nil && dataPreItem != nil {
-						date = dataCurrentItem.DataTime
-						//val = dataCurrentItem.Value - dataPreItem.Value
-						a := decimal.NewFromFloat(dataCurrentItem.Value)
-						b := decimal.NewFromFloat(dataPreItem.Value)
-						val, _ = a.Sub(b).Float64()
-					}
-				}
-				if date != "" {
-					dataTime, _ := time.Parse(utils.FormatDate, date)
-					timestamp := dataTime.UnixNano() / 1e6
-					timeStr := fmt.Sprintf("%d", timestamp)
-
-					addSql += "("
-					addSql += strconv.Itoa(edbInfoId) + "," + "'" + edbCode + "'" + "," + "'" + date + "'" + "," + utils.SubFloatToString(val, 4) + "," + "'" + nowStr + "'" +
-						"," + "'" + nowStr + "'" + "," + "1"
-					addSql += "," + "'" + timeStr + "'"
-					addSql += "),"
-					isAdd = true
-				}
-			}
-		}
-		if isAdd {
-			addSql = strings.TrimRight(addSql, ",")
-			_, err = to.Raw(addSql).Exec()
-			if err != nil {
-				return edbInfoId, err
-			}
-		}
-	}
-	return
-}
-
-// 刷新累计值转月值数据
-func RefreshCalculateLjzzy(edbInfoId int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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)
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 1)
-	if err != nil {
-		return err
-	}
-
-	yearMap := make(map[int]map[int]*EdbInfoSearchData)
-	dataLen := len(dataList)
-	for i := 0; i < dataLen; i++ {
-		item := dataList[i]
-		//日其中获取年
-		itemDate, err := time.Parse(utils.FormatDate, item.DataTime)
-		if err != nil {
-			return err
-		}
-		year := itemDate.Year()
-		month := int(itemDate.Month())
-		if monthMap, yok := yearMap[year]; yok {
-			monthMap[month] = item
-			yearMap[year] = monthMap
-		} else {
-			monthMap = make(map[int]*EdbInfoSearchData)
-			monthMap[month] = item
-			yearMap[year] = monthMap
-		}
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_ljzzy(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	nowStr := time.Now().Format(utils.FormatDateTime)
-	var isAdd bool
-
-	for yk, yv := range yearMap {
-		_, oneMonthOk := yv[1]
-		_, twoMonthOk := yv[2]
-		if !oneMonthOk && !twoMonthOk {
-			continue
-		}
-		for i := 1; i <= 12; i++ {
-			fmt.Println(yk, i, yv[i])
-			dataCurrentItem := yv[i]
-			var date string
-			var val float64
-			if i == 1 || i == 2 {
-				if _, mok := yv[1]; mok { //1月有值
-					if i == 1 {
-						date = dataCurrentItem.DataTime
-						val, _ = decimal.NewFromFloat(dataCurrentItem.Value).Float64() //a.Div(b).Float64()
-					}
-					if i == 2 {
-						dataOneItem := yv[1]
-						date = dataCurrentItem.DataTime
-						twoMonth := decimal.NewFromFloat(dataCurrentItem.Value)
-						oneMonth := decimal.NewFromFloat(dataOneItem.Value)
-						val, _ = twoMonth.Sub(oneMonth).Float64()
-					}
-				} else { //1月无值
-					dataTwoItem := yv[2]
-					if i == 1 {
-						date = strconv.Itoa(yk) + "-01-31"
-						a := decimal.NewFromFloat(dataTwoItem.Value)
-						b := decimal.NewFromFloat(2.0)
-						val, _ = a.Div(b).Float64()
-					}
-					if i == 2 {
-						date = dataCurrentItem.DataTime
-						a := decimal.NewFromFloat(dataTwoItem.Value)
-						b := decimal.NewFromFloat(2.0)
-						val, _ = a.Div(b).Float64()
-					}
-				}
-			} else {
-				dataPreItem := yv[i-1]
-				if dataCurrentItem != nil && dataPreItem != nil {
-					date = dataCurrentItem.DataTime
-					//val =  dataCurrentItem.Value - dataPreItem.Value
-					a := decimal.NewFromFloat(dataCurrentItem.Value)
-					b := decimal.NewFromFloat(dataPreItem.Value)
-					val, _ = a.Sub(b).Float64()
-				}
-			}
-			if date != "" {
-				//判断数据是否存在
-				count, err := GetEdbDataCalculateLjzzyByCodeAndDate(edbCode, date)
-				if err != nil && err.Error() != utils.ErrNoRow() {
-					return err
-				}
-				if count <= 0 {
-					dataTime, _ := time.Parse(utils.FormatDate, date)
-					timestamp := dataTime.UnixNano() / 1e6
-					timeStr := fmt.Sprintf("%d", timestamp)
-
-					addSql += "("
-					addSql += edbInfoIdStr + "," + "'" + edbCode + "'" + "," + "'" + date + "'" + "," + utils.SubFloatToString(val, 4) + "," + "'" + nowStr + "'" +
-						"," + "'" + nowStr + "'" + "," + "1"
-					addSql += "," + "'" + timeStr + "'"
-					addSql += "),"
-					isAdd = true
-				} else {
-					valStr := utils.SubFloatToString(val, 4)
-					err = ModifyEdbDataCalculateLjzzy(int64(edbInfoId), date, valStr)
-					if err != nil {
-						return err
-					}
-				}
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}
-
-type EdbInfoCalculateLjzzyDetail struct {
-	EdbInfoCalculateLjzzyId int       `orm:"column(edb_info_calculate_ljzzy_id);pk"`
-	EdbInfoId               int       `description:"指标id"`
-	EdbCode                 string    `description:"指标编码"`
-	FromEdbInfoId           int       `description:"计算指标id"`
-	FromEdbCode             string    `description:"计算指标编码"`
-	FromEdbName             string    `description:"计算指标名称"`
-	FromSource              int       `description:"计算指标来源"`
-	FromSourceName          string    `description:"计算指标来源名称"`
-	FromTag                 string    `description:"来源指标标签"`
-	Sort                    int       `description:"计算指标名称排序"`
-	CreateTime              time.Time `description:"创建时间"`
-	ModifyTime              time.Time `description:"修改时间"`
-	StartDate               string    `description:"开始日期"`
-	EndDate                 string    `description:"结束日期"`
-}
-
-func GetEdbInfoCalculateLjzzyDetail(edbInfoId int) (item *EdbInfoCalculateLjzzyDetail, 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 GetEdbDataCalculateLjzzyByCodeAndDate(edbCode string, startDate string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(1) AS count FROM edb_data_calculate_ljzzy WHERE edb_code=? AND data_time=? `
-	err = o.Raw(sql, edbCode, startDate).QueryRow(&count)
-	return
-}
-
-func ModifyEdbDataCalculateLjzzy(edbInfoId int64, dataTime, value string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` UPDATE edb_data_calculate_ljzzy SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-	_, err = o.Raw(sql, value, edbInfoId, dataTime).Exec()
-	return
-}
-
-// 刷新全部数据
-func RefreshAllCalculateLjzzy(edbInfoId, source, subSource int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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)
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 1)
-	if err != nil {
-		return err
-	}
-
-	yearMap := make(map[int]map[int]*EdbInfoSearchData)
-	dataLen := len(dataList)
-	for i := 0; i < dataLen; i++ {
-		item := dataList[i]
-		//日其中获取年
-		itemDate, err := time.Parse(utils.FormatDate, item.DataTime)
-		if err != nil {
-			return err
-		}
-		year := itemDate.Year()
-		month := int(itemDate.Month())
-		if monthMap, yok := yearMap[year]; yok {
-			monthMap[month] = item
-			yearMap[year] = monthMap
-		} else {
-			monthMap = make(map[int]*EdbInfoSearchData)
-			monthMap[month] = item
-			yearMap[year] = monthMap
-		}
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_ljzzy(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-	//获取指标所有数据
-	existDataList := make([]*EdbDataBase, 0)
-	dataTableName := GetEdbDataTableName(source, subSource)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
-	if err != nil {
-		return err
-	}
-	dataMap := make(map[string]string)
-	for _, v := range existDataList {
-		dataMap[v.DataTime] = v.Value
-	}
-	existDataMap := make(map[string]string)
-	for yk, yv := range yearMap {
-		_, oneMonthOk := yv[1]
-		_, twoMonthOk := yv[2]
-		if !oneMonthOk && !twoMonthOk {
-			continue
-		}
-		for i := 1; i <= 12; i++ {
-			fmt.Println(yk, i, yv[i])
-			dataCurrentItem := yv[i]
-			var date string
-			var val float64
-			if i == 1 || i == 2 {
-				if _, mok := yv[1]; mok { //1月有值
-					if i == 1 {
-						date = dataCurrentItem.DataTime
-						val, _ = decimal.NewFromFloat(dataCurrentItem.Value).Float64() //a.Div(b).Float64()
-					}
-					if i == 2 {
-						dataOneItem := yv[1]
-						date = dataCurrentItem.DataTime
-						twoMonth := decimal.NewFromFloat(dataCurrentItem.Value)
-						oneMonth := decimal.NewFromFloat(dataOneItem.Value)
-						val, _ = twoMonth.Sub(oneMonth).Float64()
-					}
-				} else { //1月无值
-					dataTwoItem := yv[2]
-					if i == 1 {
-						date = strconv.Itoa(yk) + "-01-31"
-						a := decimal.NewFromFloat(dataTwoItem.Value)
-						b := decimal.NewFromFloat(2.0)
-						val, _ = a.Div(b).Float64()
-					}
-					if i == 2 {
-						date = dataCurrentItem.DataTime
-						a := decimal.NewFromFloat(dataTwoItem.Value)
-						b := decimal.NewFromFloat(2.0)
-						val, _ = a.Div(b).Float64()
-					}
-				}
-			} else {
-				dataPreItem := yv[i-1]
-				if dataCurrentItem != nil && dataPreItem != nil {
-					date = dataCurrentItem.DataTime
-					//val =  dataCurrentItem.Value - dataPreItem.Value
-					a := decimal.NewFromFloat(dataCurrentItem.Value)
-					b := decimal.NewFromFloat(dataPreItem.Value)
-					val, _ = a.Sub(b).Float64()
-				}
-			}
-			if date != "" {
-				saveValue := utils.SubFloatToString(val, 4)
-				//判断数据是否存在
-				if existVal, ok := dataMap[date]; !ok {
-					dataTime, _ := time.Parse(utils.FormatDate, date)
-					timestamp := dataTime.UnixNano() / 1e6
-					timeStr := fmt.Sprintf("%d", timestamp)
-					if _, existOk := existDataMap[date]; !existOk {
-						addSql += GetAddSql(edbInfoIdStr, edbCode, date, timeStr, saveValue)
-						isAdd = true
-					}
-					existDataMap[date] = date
-				} else {
-					if existVal != saveValue {
-						sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-						sql = fmt.Sprintf(sql, dataTableName)
-						_, err = to.Raw(sql, saveValue, edbInfoId, date).Exec()
-						if err != nil {
-							return err
-						}
-					}
-				}
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			fmt.Println("RefreshAllCalculateLjzzy add Err", err.Error())
-			return
-		}
-	}
-	return
-}

models/data_manage/edb_info_calculate_nszydpjjs.go

@@ -1,373 +0,0 @@
-package data_manage
-
-import (
-	"errors"
-	"eta/eta_api/utils"
-	"fmt"
-	"github.com/beego/beego/v2/client/orm"
-	"github.com/shopspring/decimal"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type EdbInfoCalculateNszydpjjs struct {
-	EdbInfoCalculateNszydpjjsId int       `orm:"column(edb_info_calculate_nszydpjjs_id);pk"`
-	EdbInfoId                   int       `description:"指标id"`
-	EdbCode                     string    `description:"指标编码"`
-	FromEdbInfoId               int       `description:"计算指标id"`
-	FromEdbCode                 string    `description:"计算指标编码"`
-	FromEdbName                 string    `description:"计算指标名称"`
-	FromSource                  int       `description:"计算指标来源"`
-	FromSourceName              string    `description:"计算指标来源名称"`
-	FromTag                     string    `description:"来源指标标签"`
-	Sort                        int       `description:"计算指标名称排序"`
-	CreateTime                  time.Time `description:"创建时间"`
-	ModifyTime                  time.Time `description:"修改时间"`
-}
-
-// N数值移动平均计算
-func AddCalculateNszydpjjs(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfoId int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
-		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_NSZYDPJJS
-		edbInfo.SourceName = "N数值移动平均计算"
-		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
-		newEdbInfoId, tmpErr := to.Insert(edbInfo)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-		edbInfoId = int(newEdbInfoId)
-
-		//calculateItem := new(EdbInfoCalculateNszydpjjs)
-		//calculateItem.CreateTime = time.Now()
-		//calculateItem.ModifyTime = time.Now()
-		//calculateItem.Sort = 1
-		//calculateItem.EdbCode = edbCode
-		//calculateItem.EdbInfoId = edbInfoId
-		//calculateItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
-		//calculateItem.FromEdbCode = fromEdbInfo.EdbCode
-		//calculateItem.FromEdbName = fromEdbInfo.EdbName
-		//calculateItem.FromSource = fromEdbInfo.Source
-		//calculateItem.FromSourceName = fromEdbInfo.SourceName
-		//
-		//_, err = to.Insert(calculateItem)
-		//if err != nil {
-		//	return edbInfoId, err
-		//}
-
-		//关联关系
-		{
-			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
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-	} else {
-		edbInfoId = req.EdbInfoId
-		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SUB_SOURCE_EDB)
-		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
-		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
-	}
-
-	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, fromEdbInfo.SubSource, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-	var dateArr []string
-	dataMap := make(map[string]*EdbInfoSearchData)
-	for _, v := range dataList {
-		dateArr = append(dateArr, v.DataTime)
-		dataMap[v.DataTime] = v
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_nszydpjjs(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-
-	arrLen := len(dateArr)
-	for ak, av := range dateArr {
-		//处理第一个值
-		var valArr []float64
-		if findItem, ok := dataMap[av]; ok {
-			valArr = append(valArr, findItem.Value)
-		} else {
-			continue
-		}
-		if ak+1 != arrLen {
-			//处理除第一个值之外的N-1个值
-			for i := 1; i < formulaInt; i++ {
-				arrIndex := ak + i
-				if arrIndex >= arrLen {
-					break
-				}
-				arrVal := dateArr[arrIndex]
-				if findItem, ok := dataMap[arrVal]; ok {
-					valArr = append(valArr, findItem.Value)
-				} else {
-					continue
-				}
-			}
-		}
-		valArrLen := len(valArr)
-		totalVal := decimal.NewFromFloat(0.00)
-		for _, v := range valArr {
-			newDecimal := decimal.NewFromFloat(v)
-			totalVal = totalVal.Add(newDecimal)
-		}
-		af := totalVal //decimal.NewFromFloat(totalVal)
-		bf := decimal.NewFromFloat(float64(valArrLen))
-		val, _ := af.Div(bf).Float64()
-		currentDate, err := time.Parse(utils.FormatDate, av)
-		if err != nil {
-			return edbInfoId, err
-		}
-
-		timestamp := currentDate.UnixNano() / 1e6
-		timestampStr := fmt.Sprintf("%d", timestamp)
-		valStr := utils.SubFloatToString(val, 4)
-		addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, valStr)
-		isAdd = true
-	}
-
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
-	return
-}
-
-// 修改N数值移动平均计算
-func EditCalculateNszydpjjs(req *EdbInfoCalculateBatchEditReq, fromEdbInfo *EdbInfo, edbCode string, formulaInt int, oldCalculateFormula string) (edbInfoId int, err error) {
-	edbInfoId = req.EdbInfoId
-
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-	//修改指标信息
-	sql := ` UPDATE  edb_info
-			SET
-			  edb_name =?,
-              edb_name_source=?,
-			  frequency = ?,
-			  unit = ?,
-			  classify_id = ?,
-			  calculate_formula=?,
-			  modify_time = NOW()
-			WHERE edb_info_id = ? `
-	_, err = to.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, 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.Error() != utils.ErrNoRow() {
-		err = errors.New("判断指标是否改变失败,Err:" + err.Error())
-		return
-	}
-	if count <= 0 || oldCalculateFormula != req.Formula {
-		//删除，计算指标关联的，基础指标的关联关系
-		sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-		//清空原有数据
-		sql = ` DELETE FROM edb_data_calculate_nszydpjjs WHERE edb_info_id = ? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-		//关联关系
-		{
-			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_NSZYDPJJS
-			calculateMappingItem.SourceName = "N数值移动平均计算"
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-
-		edbInfoIdStr := strconv.Itoa(edbInfoId)
-		//计算数据
-		var condition string
-		var pars []interface{}
-		condition += " AND edb_info_id=? "
-		pars = append(pars, req.FromEdbInfoId)
-		dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 0)
-		if err != nil {
-			return edbInfoId, err
-		}
-		var dateArr []string
-		dataMap := make(map[string]*EdbInfoSearchData)
-		for _, v := range dataList {
-			dateArr = append(dateArr, v.DataTime)
-			dataMap[v.DataTime] = v
-		}
-
-		addSql := ` INSERT INTO edb_data_calculate_nszydpjjs(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-		var isAdd bool
-
-		arrLen := len(dateArr)
-		for ak, av := range dateArr {
-			//处理第一个值
-			var valArr []float64
-			if findItem, ok := dataMap[av]; ok {
-				valArr = append(valArr, findItem.Value)
-			} else {
-				continue
-			}
-			if ak+1 != arrLen {
-				//处理除第一个值之外的N-1个值
-				for i := 1; i < formulaInt; i++ {
-					arrIndex := ak + i
-					if arrIndex >= arrLen {
-						break
-					}
-					arrVal := dateArr[arrIndex]
-					if findItem, ok := dataMap[arrVal]; ok {
-						valArr = append(valArr, findItem.Value)
-					} else {
-						continue
-					}
-				}
-			}
-			valArrLen := len(valArr)
-			totalVal := decimal.NewFromFloat(0.00)
-			for _, v := range valArr {
-				newDecimal := decimal.NewFromFloat(v)
-				totalVal = totalVal.Add(newDecimal)
-			}
-			af := totalVal
-			bf := decimal.NewFromFloat(float64(valArrLen))
-			val, _ := af.Div(bf).Float64()
-			currentDate, err := time.Parse(utils.FormatDate, av)
-			if err != nil {
-				return edbInfoId, err
-			}
-
-			timestamp := currentDate.UnixNano() / 1e6
-			timestampStr := fmt.Sprintf("%d", timestamp)
-
-			valStr := utils.SubFloatToString(val, 4)
-			addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, valStr)
-			isAdd = true
-		}
-
-		if isAdd {
-			addSql = strings.TrimRight(addSql, ",")
-			_, err = to.Raw(addSql).Exec()
-			if err != nil {
-				return edbInfoId, err
-			}
-		}
-	}
-	return
-}
-
-type EdbInfoCalculateNszydpjjsDetail struct {
-	EdbInfoCalculateNszydpjjsId int       `orm:"column(edb_info_calculate_nszydpjjs_id);pk"`
-	EdbInfoId                   int       `description:"指标id"`
-	EdbCode                     string    `description:"指标编码"`
-	FromEdbInfoId               int       `description:"计算指标id"`
-	FromEdbCode                 string    `description:"计算指标编码"`
-	FromEdbName                 string    `description:"计算指标名称"`
-	FromSource                  int       `description:"计算指标来源"`
-	FromSourceName              string    `description:"计算指标来源名称"`
-	FromTag                     string    `description:"来源指标标签"`
-	Sort                        int       `description:"计算指标名称排序"`
-	CreateTime                  time.Time `description:"创建时间"`
-	ModifyTime                  time.Time `description:"修改时间"`
-	StartDate                   string    `description:"开始日期"`
-	EndDate                     string    `description:"结束日期"`
-}
-
-func GetEdbInfoCalculateNszydpjjsDetail(edbInfoId int) (item *EdbInfoCalculateNszydpjjsDetail, 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
-}

models/data_manage/edb_info_calculate_tbz.go

@@ -1,319 +0,0 @@
-package data_manage
-
-import (
-	"eta/eta_api/utils"
-	"fmt"
-	"github.com/beego/beego/v2/client/orm"
-	"github.com/shopspring/decimal"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type EdbInfoCalculateTbz struct {
-	EdbInfoCalculateTbzId int       `orm:"column(edb_info_calculate_tbz_id);pk"`
-	EdbInfoId             int       `description:"指标id"`
-	EdbCode               string    `description:"指标编码"`
-	FromEdbInfoId         int       `description:"计算指标id"`
-	FromEdbCode           string    `description:"计算指标编码"`
-	FromEdbName           string    `description:"计算指标名称"`
-	FromSource            int       `description:"计算指标来源"`
-	FromSourceName        string    `description:"计算指标来源名称"`
-	FromTag               string    `description:"来源指标标签"`
-	Sort                  int       `description:"计算指标名称排序"`
-	CreateTime            time.Time `description:"创建时间"`
-	ModifyTime            time.Time `description:"修改时间"`
-}
-
-// 同比值
-func AddCalculateTbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
-	fmt.Println("AddCalculateTbz")
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
-		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_TBZ
-		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
-		newEdbInfoId, tmpErr := to.Insert(edbInfo)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-		edbInfoId = int(newEdbInfoId)
-
-		//calculateItem := new(EdbInfoCalculateTbz)
-		//calculateItem.CreateTime = time.Now()
-		//calculateItem.ModifyTime = time.Now()
-		//calculateItem.Sort = 1
-		//calculateItem.EdbCode = edbCode
-		//calculateItem.EdbInfoId = edbInfoId
-		//calculateItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
-		//calculateItem.FromEdbCode = fromEdbInfo.EdbCode
-		//calculateItem.FromEdbName = fromEdbInfo.EdbName
-		//calculateItem.FromSource = fromEdbInfo.Source
-		//calculateItem.FromSourceName = fromEdbInfo.SourceName
-		//
-		//_, err = to.Insert(calculateItem)
-		//if err != nil {
-		//	return edbInfoId, err
-		//}
-
-		//关联关系
-		{
-			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
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-
-	} else {
-		edbInfoId = req.EdbInfoId
-		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_TBZ, utils.DATA_SUB_SOURCE_EDB)
-		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
-		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
-	}
-
-	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, fromEdbInfo.SubSource, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-	var dateArr []string
-	dataMap := make(map[string]*EdbInfoSearchData)
-	for _, v := range dataList {
-		dateArr = append(dateArr, v.DataTime)
-		dataMap[v.DataTime] = v
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_tbz(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	for _, av := range dateArr {
-		//fmt.Println(ak, av)
-		currentItem := dataMap[av]
-		if currentItem != nil {
-			//当前日期
-			currentDate, err := time.Parse(utils.FormatDate, av)
-			if err != nil {
-				return edbInfoId, err
-			}
-			//上一年的日期
-			preDate := currentDate.AddDate(-1, 0, 0)
-			preDateStr := preDate.Format(utils.FormatDate)
-			if findItem, ok := dataMap[preDateStr]; ok { //上一年同期找到
-				//dataTime, _ := time.Parse(utils.FormatDate, date)
-				if _, ok := existMap[edbCode+av]; !ok {
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					val := TbzDiv(currentItem.Value, findItem.Value)
-					addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-					isAdd = true
-					utils.FileLog.Info("同期找到:" + av + ";" + preDateStr)
-				}
-				existMap[edbCode+av] = av
-			} else {
-				if fromEdbInfo.Frequency == "月度" { //向上和向下，各找一个月
-					nextDateDay := preDate
-					preDateDay := preDate
-					for i := 0; i <= 35; i++ {
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-							if _, ok := existMap[edbCode+av]; !ok {
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TbzDiv(currentItem.Value, findItem.Value)
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							}
-							existMap[edbCode+av] = av
-							break
-						} else {
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								if _, ok := existMap[edbCode+av]; !ok {
-									timestamp := currentDate.UnixNano() / 1e6
-									timestampStr := fmt.Sprintf("%d", timestamp)
-									val := TbzDiv(currentItem.Value, findItem.Value)
-
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								}
-								existMap[edbCode+av] = av
-								break
-							}
-						}
-						nextDateDay = nextDateDay.AddDate(0, 0, 1)
-						preDateDay = preDateDay.AddDate(0, 0, -1)
-					}
-				} else if fromEdbInfo.Frequency == "季度" || fromEdbInfo.Frequency == "年度" {
-					if findItem, ok := dataMap[preDateStr]; ok { //上一年同期->下一个月找到
-						if _, ok := existMap[edbCode+av]; !ok {
-							timestamp := currentDate.UnixNano() / 1e6
-							timestampStr := fmt.Sprintf("%d", timestamp)
-							val := TbzDiv(currentItem.Value, findItem.Value)
-
-							addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-							isAdd = true
-						}
-						existMap[edbCode+av] = av
-						break
-					}
-				} else {
-					nextDateDay := preDate
-					preDateDay := preDate
-
-					for i := 0; i < 35; i++ {
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-							if _, ok := existMap[edbCode+av]; !ok {
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TbzDiv(currentItem.Value, findItem.Value)
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							}
-							existMap[edbCode+av] = av
-							break
-						} else {
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								if _, ok := existMap[edbCode+av]; !ok {
-									timestamp := currentDate.UnixNano() / 1e6
-									timestampStr := fmt.Sprintf("%d", timestamp)
-									val := TbzDiv(currentItem.Value, findItem.Value)
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								}
-								existMap[edbCode+av] = av
-								break
-							} else {
-								//fmt.Println("pre not find:", preDateStr, "i:", i)
-							}
-						}
-						nextDateDay = nextDateDay.AddDate(0, 0, 1)
-						preDateDay = preDateDay.AddDate(0, 0, -1)
-					}
-				}
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
-	return
-}
-
-func GetAddSql(edbInfoId, edbCode, dataTime, timestampStr string, value string) (addSql string) {
-	nowStr := time.Now().Format(utils.FormatDateTime)
-	addSql += "("
-	addSql += edbInfoId + "," + "'" + edbCode + "'" + "," + "'" + dataTime + "'" + "," + value + "," + "'" + nowStr + "'" +
-		"," + "'" + nowStr + "'" + "," + "1"
-	addSql += "," + "'" + timestampStr + "'"
-	addSql += "),"
-	return
-}
-
-func TbzDiv(a, b float64) string {
-	var valStr string
-	if b != 0 {
-		af := decimal.NewFromFloat(float64(a))
-		bf := decimal.NewFromFloat(float64(b))
-		val, _ := af.Div(bf).Float64()
-		val = val - 1
-		valStr = utils.SubFloatToString(val, 4)
-	} else {
-		valStr = "0"
-	}
-	return valStr
-}
-
-type EdbInfoCalculateTbzDetail struct {
-	EdbInfoCalculateTbzId int       `orm:"column(edb_info_calculate_tbz_id);pk"`
-	EdbInfoId             int       `description:"指标id"`
-	EdbCode               string    `description:"指标编码"`
-	FromEdbInfoId         int       `description:"计算指标id"`
-	FromEdbCode           string    `description:"计算指标编码"`
-	FromEdbName           string    `description:"计算指标名称"`
-	FromSource            int       `description:"计算指标来源"`
-	FromSourceName        string    `description:"计算指标来源名称"`
-	FromTag               string    `description:"来源指标标签"`
-	Sort                  int       `description:"计算指标名称排序"`
-	CreateTime            time.Time `description:"创建时间"`
-	ModifyTime            time.Time `description:"修改时间"`
-	StartDate             string    `description:"开始日期"`
-	EndDate               string    `description:"结束日期"`
-}
-
-func GetEdbInfoCalculateTbzDetail(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 GetEdbDataCalculateTbzByCodeAndDate(edbCode string, startDate string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(1) AS count FROM edb_data_calculate_tbz WHERE edb_code=? AND data_time=? `
-	err = o.Raw(sql, edbCode, startDate).QueryRow(&count)
-	return
-}
-
-func ModifyEdbDataCalculateTbz(edbInfoId int64, dataTime, value string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` UPDATE edb_data_calculate_tbz SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-	_, err = o.Raw(sql, value, edbInfoId, dataTime).Exec()
-	return
-}

models/data_manage/edb_info_calculate_tcz.go

@@ -1,1019 +0,0 @@
-package data_manage
-
-import (
-	"errors"
-	"eta/eta_api/utils"
-	"fmt"
-	"github.com/beego/beego/v2/client/orm"
-	"github.com/shopspring/decimal"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type EdbInfoCalculateTcz struct {
-	EdbInfoCalculateTbzId int       `orm:"column(edb_info_calculate_tcz_id);pk"`
-	EdbInfoId             int       `description:"指标id"`
-	EdbCode               string    `description:"指标编码"`
-	FromEdbInfoId         int       `description:"计算指标id"`
-	FromEdbCode           string    `description:"计算指标编码"`
-	FromEdbName           string    `description:"计算指标名称"`
-	FromSource            int       `description:"计算指标来源"`
-	FromSourceName        string    `description:"计算指标来源名称"`
-	FromTag               string    `description:"来源指标标签"`
-	Sort                  int       `description:"计算指标名称排序"`
-	CreateTime            time.Time `description:"创建时间"`
-	ModifyTime            time.Time `description:"修改时间"`
-}
-
-// 同差值
-func AddCalculateTcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			fmt.Println("err:", err.Error())
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-	fmt.Println("req.EdbInfoId:", req.EdbInfoId)
-	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
-		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_TCZ
-		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
-		newEdbInfoId, tmpErr := to.Insert(edbInfo)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-		edbInfoId = int(newEdbInfoId)
-
-		//calculateItem := new(EdbInfoCalculateTcz)
-		//calculateItem.CreateTime = time.Now()
-		//calculateItem.ModifyTime = time.Now()
-		//calculateItem.Sort = 1
-		//calculateItem.EdbCode = edbCode
-		//calculateItem.EdbInfoId = edbInfoId
-		//calculateItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
-		//calculateItem.FromEdbCode = fromEdbInfo.EdbCode
-		//calculateItem.FromEdbName = fromEdbInfo.EdbName
-		//calculateItem.FromSource = fromEdbInfo.Source
-		//calculateItem.FromSourceName = fromEdbInfo.SourceName
-		//
-		//_, err = to.Insert(calculateItem)
-		//if err != nil {
-		//	return edbInfoId, err
-		//}
-
-		//关联关系
-		{
-			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
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-	} else {
-		edbInfoId = req.EdbInfoId
-		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_TCZ, utils.DATA_SUB_SOURCE_EDB)
-		fmt.Println("dataTableName:", dataTableName)
-		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
-		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
-
-	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)
-	}
-
-	fmt.Println("EdbInfoId:", req.FromEdbInfoId)
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-	var dateArr []string
-	dataMap := make(map[string]*EdbInfoSearchData)
-	for _, v := range dataList {
-		dateArr = append(dateArr, v.DataTime)
-		dataMap[v.DataTime] = v
-	}
-	fmt.Println("Frequency:", fromEdbInfo.Frequency)
-	addSql := ` INSERT INTO edb_data_calculate_tcz(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	for _, av := range dateArr {
-		//fmt.Println("dateArr:", ak, av)
-		currentItem := dataMap[av]
-		if currentItem != nil {
-			//当前日期
-			currentDate, err := time.Parse(utils.FormatDate, av)
-			if err != nil {
-				return edbInfoId, err
-			}
-			//上一年的日期
-			preDate := currentDate.AddDate(-1, 0, 0)
-			preDateStr := preDate.Format(utils.FormatDate)
-			if findItem, ok := dataMap[preDateStr]; ok { //上一年同期找到
-				//dataTime, _ := time.Parse(utils.FormatDate, date)
-				if _, ok := existMap[edbCode+av]; !ok {
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-
-					val := TczSub(currentItem.Value, findItem.Value)
-					addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-					isAdd = true
-				}
-				existMap[edbCode+av] = av
-			} else {
-				if fromEdbInfo.Frequency == "月度" { //向上和向下，各找一个月
-					nextDateDay := preDate
-					preDateDay := preDate
-					for i := 0; i <= 35; i++ {
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //下一年同期->下一个月找到
-							if _, ok := existMap[edbCode+av]; !ok {
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TczSub(currentItem.Value, findItem.Value)
-
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							}
-							existMap[edbCode+av] = av
-							break
-						} else {
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								if _, ok := existMap[edbCode+av]; !ok {
-									timestamp := currentDate.UnixNano() / 1e6
-									timestampStr := fmt.Sprintf("%d", timestamp)
-									val := TczSub(currentItem.Value, findItem.Value)
-
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								}
-								existMap[edbCode+av] = av
-								break
-							}
-						}
-						nextDateDay = nextDateDay.AddDate(0, 0, 1)
-						preDateDay = preDateDay.AddDate(0, 0, -1)
-					}
-				} else if fromEdbInfo.Frequency == "季度" || fromEdbInfo.Frequency == "年度" {
-					if findItem, ok := dataMap[preDateStr]; ok { //上一年同期->下一个月找到
-						if _, ok := existMap[edbCode+av]; !ok {
-							timestamp := currentDate.UnixNano() / 1e6
-							timestampStr := fmt.Sprintf("%d", timestamp)
-							val := TczSub(currentItem.Value, findItem.Value)
-							addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-							isAdd = true
-						}
-						existMap[edbCode+av] = av
-						break
-					}
-				} else {
-					nextDateDay := preDate
-					preDateDay := preDate
-					for i := 0; i < 35; i++ {
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-							if _, ok := existMap[edbCode+av]; !ok {
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TczSub(currentItem.Value, findItem.Value)
-
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							}
-							existMap[edbCode+av] = av
-							break
-						} else {
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								if _, ok := existMap[edbCode+av]; !ok {
-									timestamp := currentDate.UnixNano() / 1e6
-									timestampStr := fmt.Sprintf("%d", timestamp)
-									val := TczSub(currentItem.Value, findItem.Value)
-
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								}
-								existMap[edbCode+av] = av
-								break
-							} else {
-
-							}
-						}
-						nextDateDay = nextDateDay.AddDate(0, 0, 1)
-						preDateDay = preDateDay.AddDate(0, 0, -1)
-					}
-				}
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
-	return
-}
-
-func TczSub(a, b float64) string {
-	af := decimal.NewFromFloat(float64(a))
-	fmt.Println(af)
-	bf := decimal.NewFromFloat(float64(b))
-	val, _ := af.Sub(bf).Float64()
-	valStr := utils.SubFloatToString(val, 4)
-	return valStr
-}
-
-// 同差值
-func EditCalculateTcz(req *EdbInfoCalculateBatchEditReq, fromEdbInfo *EdbInfo, edbCode string) (edbInfoId int, err error) {
-	edbInfoId = req.EdbInfoId
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			fmt.Println("err:", err.Error())
-			_ = to.Rollback()
-		} else {
-			_ = to.Commit()
-		}
-	}()
-
-	//修改指标信息
-	sql := ` UPDATE  edb_info
-			SET
-			  edb_name =?,
-			  edb_name_source=?,
-			  frequency = ?,
-			  unit = ?,
-			  classify_id = ?,
-			  modify_time = NOW()
-			WHERE edb_info_id = ? `
-	_, err = to.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, 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 {
-		//删除指标关联计算指标
-		//sql := ` DELETE FROM edb_info_calculate_tcz WHERE edb_info_id = ? `
-		//_, err = to.Raw(sql, edbInfoId).Exec()
-		//if err != nil {
-		//	return
-		//}
-		//
-		//calculateItem := new(EdbInfoCalculateTcz)
-		//calculateItem.CreateTime = time.Now()
-		//calculateItem.ModifyTime = time.Now()
-		//calculateItem.Sort = 1
-		//calculateItem.EdbCode = edbCode
-		//calculateItem.EdbInfoId = edbInfoId
-		//calculateItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
-		//calculateItem.FromEdbCode = fromEdbInfo.EdbCode
-		//calculateItem.FromEdbName = fromEdbInfo.EdbName
-		//calculateItem.FromSource = fromEdbInfo.Source
-		//calculateItem.FromSourceName = fromEdbInfo.SourceName
-		//
-		//_, err = to.Insert(calculateItem)
-		//if err != nil {
-		//	return
-		//}
-
-		//删除，计算指标关联的，基础指标的关联关系
-		sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			return
-		}
-
-		//清空原有数据
-		sql = ` DELETE FROM edb_data_calculate_tcz WHERE edb_info_id = ? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-
-		//关联关系
-		{
-			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_TCZ
-			calculateMappingItem.SourceName = "同差值"
-			_, err = to.Insert(calculateMappingItem)
-			if err != nil {
-				return
-			}
-		}
-
-		edbInfoIdStr := strconv.Itoa(edbInfoId)
-
-		//计算数据
-		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, fromEdbInfo.SubSource, 0)
-		if err != nil {
-			return edbInfoId, err
-		}
-		var dateArr []string
-		dataMap := make(map[string]*EdbInfoSearchData)
-		for _, v := range dataList {
-			dateArr = append(dateArr, v.DataTime)
-			dataMap[v.DataTime] = v
-		}
-
-		addSql := ` INSERT INTO edb_data_calculate_tcz(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-		var isAdd bool
-		for ak, av := range dateArr {
-			fmt.Println(ak, av)
-			currentItem := dataMap[av]
-			if currentItem != nil {
-				//当前日期
-				currentDate, err := time.Parse(utils.FormatDate, av)
-				if err != nil {
-					return edbInfoId, err
-				}
-				//上一年的日期
-				preDate := currentDate.AddDate(-1, 0, 0)
-				preDateStr := preDate.Format(utils.FormatDate)
-				if findItem, ok := dataMap[preDateStr]; ok { //上一年同期找到
-					//dataTime, _ := time.Parse(utils.FormatDate, date)
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-
-					val := TczSub(currentItem.Value, findItem.Value)
-					addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-					isAdd = true
-					utils.FileLog.Info("同期找到:" + av + ";" + preDateStr)
-					continue
-				} else {
-					if fromEdbInfo.Frequency == "月度" { //向上和向下，各找一个月
-						nextDateDay := preDate.AddDate(0, 1, 0)
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-
-						preDateDay := preDate.AddDate(0, -1, 0)
-						preDateDayStr := preDateDay.Format(utils.FormatDate)
-
-						for i := 0; i <= 6; i++ {
-							if i >= 1 {
-								nextDateDay = nextDateDay.AddDate(0, 0, i)
-								nextDateDayStr = nextDateDay.Format(utils.FormatDate)
-							}
-							if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TczSub(currentItem.Value, findItem.Value)
-
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-								break
-							} else {
-								if i >= 1 {
-									preDateDay = preDate.AddDate(0, 0, -i)
-									preDateDayStr = nextDateDay.Format(utils.FormatDate)
-								}
-								if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-									timestamp := currentDate.UnixNano() / 1e6
-									timestampStr := fmt.Sprintf("%d", timestamp)
-									val := TczSub(currentItem.Value, findItem.Value)
-
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-									break
-								}
-							}
-						}
-					} else if fromEdbInfo.Frequency == "季度" || fromEdbInfo.Frequency == "年度" {
-						if findItem, ok := dataMap[preDateStr]; ok { //上一年同期->下一个月找到
-							timestamp := currentDate.UnixNano() / 1e6
-							timestampStr := fmt.Sprintf("%d", timestamp)
-							val := TczSub(currentItem.Value, findItem.Value)
-
-							addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-							isAdd = true
-							break
-						}
-					} else {
-						nextDateDay := preDate.AddDate(0, 0, 1)
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-
-						preDateDay := preDate.AddDate(0, 0, -1)
-						preDateDayStr := preDateDay.Format(utils.FormatDate)
-
-						for i := 0; i < 35; i++ {
-							if i >= 1 {
-								nextDateDay = nextDateDay.AddDate(0, 0, i)
-								nextDateDayStr = nextDateDay.Format(utils.FormatDate)
-							}
-							if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TczSub(currentItem.Value, findItem.Value)
-
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-								break
-							} else {
-								if i >= 1 {
-									preDateDay = preDate.AddDate(0, 0, -i)
-									preDateDayStr = nextDateDay.Format(utils.FormatDate)
-								}
-								if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-									timestamp := currentDate.UnixNano() / 1e6
-									timestampStr := fmt.Sprintf("%d", timestamp)
-									val := TczSub(currentItem.Value, findItem.Value)
-
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-									break
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-		if isAdd {
-			addSql = strings.TrimRight(addSql, ",")
-			_, err = to.Raw(addSql).Exec()
-			if err != nil {
-				return edbInfoId, err
-			}
-		}
-	}
-	return
-}
-
-// 刷新同差值数据
-func RefreshCalculateTcz(edbInfoId int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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)
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 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
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_tcz(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-	for ak, av := range dateArr {
-		fmt.Println(ak, av)
-		currentItem := dataMap[av]
-		if currentItem != nil {
-			//当前日期
-			currentDate, err := time.Parse(utils.FormatDate, av)
-			if err != nil {
-				return err
-			}
-			//上一年的日期
-			preDate := currentDate.AddDate(-1, 0, 0)
-			preDateStr := preDate.Format(utils.FormatDate)
-			if findItem, ok := dataMap[preDateStr]; ok { //上一年同期找到
-				//dataTime, _ := time.Parse(utils.FormatDate, date)
-				timestamp := currentDate.UnixNano() / 1e6
-				timestampStr := fmt.Sprintf("%d", timestamp)
-				val := TczSub(currentItem.Value, findItem.Value)
-
-				count, err := GetEdbDataCalculateTczByCodeAndDate(edbCode, av)
-				if err != nil && err.Error() != utils.ErrNoRow() {
-					return err
-				}
-				if count <= 0 {
-					addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-					isAdd = true
-				} else {
-					err = ModifyEdbDataCalculateTcz(int64(edbInfoId), av, val)
-					if err != nil {
-						return err
-					}
-				}
-				utils.FileLog.Info("同期找到:" + av + ";" + preDateStr)
-				continue
-			} else {
-				if fromEdbInfo.Frequency == "月度" { //向上和向下，各找一个月
-					for i := 0; i <= 35; i++ {
-						nextDateDay := preDate.AddDate(0, 0, 1)
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-							timestamp := currentDate.UnixNano() / 1e6
-							timestampStr := fmt.Sprintf("%d", timestamp)
-							val := TczSub(currentItem.Value, findItem.Value)
-
-							count, err := GetEdbDataCalculateTczByCodeAndDate(edbCode, av)
-							if err != nil && err.Error() != utils.ErrNoRow() {
-								return err
-							}
-							if count <= 0 {
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							} else {
-								err = ModifyEdbDataCalculateTcz(int64(edbInfoId), av, val)
-								if err != nil {
-									return err
-								}
-							}
-							break
-						} else {
-							preDateDay := preDate.AddDate(0, 0, -1)
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TczSub(currentItem.Value, findItem.Value)
-
-								count, err := GetEdbDataCalculateTczByCodeAndDate(edbCode, av)
-								if err != nil && err.Error() != utils.ErrNoRow() {
-									return err
-								}
-								if count <= 0 {
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								} else {
-									err = ModifyEdbDataCalculateTcz(int64(edbInfoId), av, val)
-									if err != nil {
-										return err
-									}
-								}
-								break
-							}
-						}
-					}
-				} else if fromEdbInfo.Frequency == "季度" || fromEdbInfo.Frequency == "年度" {
-					if findItem, ok := dataMap[preDateStr]; ok { //上一年同期->下一个月找到
-						timestamp := currentDate.UnixNano() / 1e6
-						timestampStr := fmt.Sprintf("%d", timestamp)
-						val := TczSub(currentItem.Value, findItem.Value)
-
-						count, err := GetEdbDataCalculateTczByCodeAndDate(edbCode, av)
-						if err != nil && err.Error() != utils.ErrNoRow() {
-							return err
-						}
-						if count <= 0 {
-							addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-							isAdd = true
-						} else {
-							err = ModifyEdbDataCalculateTcz(int64(edbInfoId), av, val)
-							if err != nil {
-								return err
-							}
-						}
-						break
-					}
-				} else {
-					for i := 0; i < 35; i++ {
-						nextDateDay := preDate.AddDate(0, 0, 1)
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-							timestamp := currentDate.UnixNano() / 1e6
-							timestampStr := fmt.Sprintf("%d", timestamp)
-							val := TczSub(currentItem.Value, findItem.Value)
-
-							count, err := GetEdbDataCalculateTczByCodeAndDate(edbCode, av)
-							if err != nil && err.Error() != utils.ErrNoRow() {
-								return err
-							}
-							if count <= 0 {
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							} else {
-								err = ModifyEdbDataCalculateTcz(int64(edbInfoId), av, val)
-								if err != nil {
-									return err
-								}
-							}
-							break
-						} else {
-							preDateDay := preDate.AddDate(0, 0, -1)
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TczSub(currentItem.Value, findItem.Value)
-
-								count, err := GetEdbDataCalculateTczByCodeAndDate(edbCode, av)
-								if err != nil && err.Error() != utils.ErrNoRow() {
-									return err
-								}
-								if count <= 0 {
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								} else {
-									err = ModifyEdbDataCalculateTcz(int64(edbInfoId), av, val)
-									if err != nil {
-										return err
-									}
-								}
-								break
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}
-
-type EdbInfoCalculateTczDetail struct {
-	EdbInfoCalculateTczId int       `orm:"column(edb_info_calculate_tcz_id);pk"`
-	EdbInfoId             int       `description:"指标id"`
-	EdbCode               string    `description:"指标编码"`
-	FromEdbInfoId         int       `description:"计算指标id"`
-	FromEdbCode           string    `description:"计算指标编码"`
-	FromEdbName           string    `description:"计算指标名称"`
-	FromSource            int       `description:"计算指标来源"`
-	FromSourceName        string    `description:"计算指标来源名称"`
-	FromTag               string    `description:"来源指标标签"`
-	Sort                  int       `description:"计算指标名称排序"`
-	CreateTime            time.Time `description:"创建时间"`
-	ModifyTime            time.Time `description:"修改时间"`
-	StartDate             string    `description:"开始日期"`
-	EndDate               string    `description:"结束日期"`
-}
-
-func GetEdbInfoCalculateTczDetail(edbInfoId int) (item *EdbInfoCalculateTczDetail, 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 GetEdbDataCalculateTczByCodeAndDate(edbCode string, startDate string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(1) AS count FROM edb_data_calculate_tcz WHERE edb_code=? AND data_time=? `
-	err = o.Raw(sql, edbCode, startDate).QueryRow(&count)
-	return
-}
-
-func ModifyEdbDataCalculateTcz(edbInfoId int64, dataTime, value string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` UPDATE edb_data_calculate_tcz SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-	_, err = o.Raw(sql, value, edbInfoId, dataTime).Exec()
-	return
-}
-
-// 刷新全部同差值数据
-func RefreshAllCalculateTcz(edbInfoId, source, subSource int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			_ = to.Rollback()
-		} else {
-			_ = to.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)
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 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
-	}
-	//获取指标所有数据
-	existDataList := make([]*EdbDataBase, 0)
-	dataTableName := GetEdbDataTableName(source, subSource)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
-	if err != nil {
-		return err
-	}
-	existDataMap := make(map[string]string)
-	for _, v := range existDataList {
-		existDataMap[v.DataTime] = v.Value
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_tcz(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-	existAddDataMap := make(map[string]string)
-	for _, av := range dateArr {
-		currentItem := dataMap[av]
-		if currentItem != nil {
-			//当前日期
-			currentDate, err := time.Parse(utils.FormatDate, av)
-			if err != nil {
-				return err
-			}
-			//上一年的日期
-			preDate := currentDate.AddDate(-1, 0, 0)
-			preDateStr := preDate.Format(utils.FormatDate)
-			if findItem, ok := dataMap[preDateStr]; ok { //上一年同期找到
-				//dataTime, _ := time.Parse(utils.FormatDate, date)
-				timestamp := currentDate.UnixNano() / 1e6
-				timestampStr := fmt.Sprintf("%d", timestamp)
-				val := TczSub(currentItem.Value, findItem.Value)
-
-				if existVal, ok := existDataMap[av]; !ok {
-					if _, existOk := existAddDataMap[av]; !existOk {
-						addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-						isAdd = true
-					}
-					existAddDataMap[av] = av
-				} else {
-					if existVal != val {
-						sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-						sql = fmt.Sprintf(sql, dataTableName)
-						_, err = to.Raw(sql, val, edbInfoId, av).Exec()
-						if err != nil {
-							return err
-						}
-					}
-				}
-				utils.FileLog.Info("同期找到:" + av + ";" + preDateStr)
-				continue
-			} else {
-				if fromEdbInfo.Frequency == "月度" { //向上和向下，各找一个月
-					for i := 0; i <= 35; i++ {
-						nextDateDay := preDate.AddDate(0, 0, 1)
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-							timestamp := currentDate.UnixNano() / 1e6
-							timestampStr := fmt.Sprintf("%d", timestamp)
-							val := TczSub(currentItem.Value, findItem.Value)
-
-							if existVal, ok := existDataMap[av]; !ok {
-								if _, existOk := existAddDataMap[av]; !existOk {
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								}
-								existAddDataMap[av] = av
-							} else {
-								if existVal != val {
-									sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-									sql = fmt.Sprintf(sql, dataTableName)
-									_, err = to.Raw(sql, val, edbInfoId, av).Exec()
-									if err != nil {
-										return err
-									}
-								}
-							}
-							break
-						} else {
-							preDateDay := preDate.AddDate(0, 0, -1)
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TczSub(currentItem.Value, findItem.Value)
-
-								if existVal, ok := existDataMap[av]; !ok {
-									if _, existOk := existAddDataMap[av]; !existOk {
-										addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-										isAdd = true
-									}
-									existAddDataMap[av] = av
-								} else {
-									if existVal != val {
-										sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-										sql = fmt.Sprintf(sql, dataTableName)
-										_, err = to.Raw(sql, val, edbInfoId, av).Exec()
-										if err != nil {
-											return err
-										}
-									}
-								}
-								break
-							}
-						}
-					}
-				} else if fromEdbInfo.Frequency == "季度" || fromEdbInfo.Frequency == "年度" {
-					if findItem, ok := dataMap[preDateStr]; ok { //上一年同期->下一个月找到
-						timestamp := currentDate.UnixNano() / 1e6
-						timestampStr := fmt.Sprintf("%d", timestamp)
-						val := TczSub(currentItem.Value, findItem.Value)
-
-						if existVal, ok := existDataMap[av]; !ok {
-							if _, existOk := existAddDataMap[av]; !existOk {
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							}
-							existAddDataMap[av] = av
-						} else {
-							if existVal != val {
-								sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-								sql = fmt.Sprintf(sql, dataTableName)
-								_, err = to.Raw(sql, val, edbInfoId, av).Exec()
-								if err != nil {
-									return err
-								}
-							}
-						}
-						break
-					}
-				} else {
-					for i := 0; i < 35; i++ {
-						nextDateDay := preDate.AddDate(0, 0, 1)
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-							timestamp := currentDate.UnixNano() / 1e6
-							timestampStr := fmt.Sprintf("%d", timestamp)
-							val := TczSub(currentItem.Value, findItem.Value)
-
-							if existVal, ok := existDataMap[av]; !ok {
-								if _, existOk := existAddDataMap[av]; !existOk {
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								}
-								existAddDataMap[av] = av
-							} else {
-								if existVal != val {
-									sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-									sql = fmt.Sprintf(sql, dataTableName)
-									_, err = to.Raw(sql, val, edbInfoId, av).Exec()
-									if err != nil {
-										return err
-									}
-								}
-							}
-							break
-						} else {
-							preDateDay := preDate.AddDate(0, 0, -1)
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TczSub(currentItem.Value, findItem.Value)
-
-								if existVal, ok := existDataMap[av]; !ok {
-									if _, existOk := existAddDataMap[av]; !existOk {
-										addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-										isAdd = true
-									}
-									existAddDataMap[av] = av
-								} else {
-									if existVal != val {
-										sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-										sql = fmt.Sprintf(sql, dataTableName)
-										_, err = to.Raw(sql, val, edbInfoId, av).Exec()
-										if err != nil {
-											return err
-										}
-									}
-								}
-								break
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}

models/db.go

@@ -306,14 +306,7 @@ func initEdbData() {
 		new(data_manage.ManualUser),
 		new(data_manage.EdbInfoCalculate),
 		new(data_manage.EdbDataCalculate),
-		new(data_manage.EdbInfoCalculateLjzzy),
-		new(data_manage.EdbInfoCalculateTbz),
-		new(data_manage.EdbInfoCalculateTcz),
-		new(data_manage.EdbInfoCalculateNszydpjjs),
 		new(data_manage.SearchKeyword),
-		new(data_manage.EdbInfoCalculateHbz),
-		new(data_manage.EdbInfoCalculateHcz),
-		new(data_manage.EdbInfoCalculateBp),
 		new(data_manage.BaseFromSmm),
 		new(data_manage.BaseFromSmmIndex),
 		new(data_manage.BaseFromSmmData),