eta_mobile/models/data_manage/edb_info_calculate_bp.go

package data_manage

import (
	"eta/eta_mobile/utils"
	"fmt"
	"github.com/beego/beego/v2/client/orm"
	"github.com/shopspring/decimal"
	"strconv"
	"strings"
	"time"
)

// 变频
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
}