eta_index_lib/models/edb_data_calculate_tbz.go

package models

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

// AddCalculateTbz 同比值
func AddCalculateTbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
	fmt.Println("AddCalculateTbz")
	o := orm.NewOrm()
	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)

		//关联关系
		{
			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)
		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
		if err != nil {
			return
		}
	}

	edbInfoIdStr := strconv.Itoa(edbInfoId)

	//计算数据
	var condition string
	var pars []interface{}
	condition += " AND edb_info_id=? "
	if req.EdbInfoId <= 0 {
		pars = append(pars, req.FromEdbInfoId)
	} else {
		pars = append(pars, fromEdbInfo.EdbInfoId)
	}
	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
	if err != nil {
		return edbInfoId, err
	}
	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 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
}