eta_api/models/data_manage/factor_edb_series.go

package data_manage

import (
	"encoding/json"
	"eta/eta_api/global"
	"eta/eta_api/utils"
	"fmt"
	"strings"
	"time"
)

const (
	FactorEdbSeriesCalculateNone = 0
	FactorEdbSeriesCalculating   = 1
	FactorEdbSeriesCalculated    = 2
)

// FactorEdbSeries 因子指标系列表
type FactorEdbSeries struct {
	FactorEdbSeriesId int       `gorm:"column:factor_edb_series_id;primaryKey"`
	SeriesName        string    `description:"系列名称"`
	EdbInfoType       int       `description:"关联指标类型：0-普通指标；1-预测指标"`
	CalculateStep     string    `description:"计算步骤-JSON"`
	CalculateState    int       `description:"计算状态: 0-无计算; 1-计算中; 2-计算完成"`
	CreateTime        time.Time `description:"创建时间"`
	ModifyTime        time.Time `description:"修改时间"`
}

func (m *FactorEdbSeries) TableName() string {
	return "factor_edb_series"
}

type FactorEdbSeriesCols struct {
	PrimaryId      string
	SeriesName     string
	EdbInfoType    string
	CalculateStep  string
	CalculateState string
	CreateTime     string
	ModifyTime     string
}

func (m *FactorEdbSeries) Cols() FactorEdbSeriesCols {
	return FactorEdbSeriesCols{
		PrimaryId:      "factor_edb_series_id",
		SeriesName:     "series_name",
		EdbInfoType:    "edb_info_type",
		CalculateStep:  "calculate_step",
		CalculateState: "calculate_state",
		CreateTime:     "create_time",
		ModifyTime:     "modify_time",
	}
}

func (m *FactorEdbSeries) Create() (err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Create(m).Error
	return
}

func (m *FactorEdbSeries) CreateMulti(items []*FactorEdbSeries) (err error) {
	if len(items) == 0 {
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	err = o.CreateInBatches(items, utils.MultiAddNum).Error
	return
}

func (m *FactorEdbSeries) Update(cols []string) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Model(m).Select(cols).Updates(m).Error
	return
}

func (m *FactorEdbSeries) Remove() (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
	err = o.Exec(sql, m.FactorEdbSeriesId).Error
	return
}

func (m *FactorEdbSeries) MultiRemove(ids []int) (err error) {
	if len(ids) == 0 {
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s IN (%s)`, m.TableName(), m.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
	err = o.Exec(sql, ids).Error
	return
}

func (m *FactorEdbSeries) RemoveByCondition(condition string, pars []interface{}) (err error) {
	if condition == "" {
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, m.TableName(), condition)
	err = o.Exec(sql, pars...).Error
	return
}

func (m *FactorEdbSeries) GetItemById(id int) (item *FactorEdbSeries, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
	err = o.Raw(sql, id).First(&item).Error
	return
}

func (m *FactorEdbSeries) GetItemByCondition(condition string, pars []interface{}, orderRule string) (item *FactorEdbSeries, err error) {
	o := global.DbMap[utils.DbNameIndex]
	order := ``
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT * FROM %s WHERE 1=1 %s %s LIMIT 1`, m.TableName(), condition, order)
	err = o.Raw(sql, pars...).First(&item).Error
	return
}

func (m *FactorEdbSeries) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
	err = o.Raw(sql, pars...).Scan(&count).Error
	return
}

func (m *FactorEdbSeries) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*FactorEdbSeries, err error) {
	o := global.DbMap[utils.DbNameIndex]
	fields := strings.Join(fieldArr, ",")
	if len(fieldArr) == 0 {
		fields = `*`
	}
	order := fmt.Sprintf(`ORDER BY %s DESC`, m.Cols().CreateTime)
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)
	err = o.Raw(sql, pars...).Find(&items).Error
	return
}

func (m *FactorEdbSeries) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*FactorEdbSeries, err error) {
	o := global.DbMap[utils.DbNameIndex]
	fields := strings.Join(fieldArr, ",")
	if len(fieldArr) == 0 {
		fields = `*`
	}
	order := fmt.Sprintf(`ORDER BY %s DESC`, m.Cols().CreateTime)
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s LIMIT ?,?`, fields, m.TableName(), condition, order)
	err = o.Raw(sql, append(pars, startSize, pageSize)...).Find(&items).Error
	return
}

// FactorEdbSeriesItem 多因子系列信息
type FactorEdbSeriesItem struct {
	SeriesId      int                            `description:"多因子系列ID"`
	SeriesName    string                         `description:"系列名称"`
	EdbInfoType   int                            `description:"关联指标类型：0-普通指标；1-预测指标"`
	CalculateStep []FactorEdbSeriesCalculatePars `description:"计算步骤-JSON"`
	CreateTime    string                         `description:"创建时间"`
	ModifyTime    string                         `description:"修改时间"`
}

func (m *FactorEdbSeries) Format2Item() (item *FactorEdbSeriesItem) {
	item = new(FactorEdbSeriesItem)
	item.SeriesId = m.FactorEdbSeriesId
	item.SeriesName = m.SeriesName
	item.EdbInfoType = m.EdbInfoType
	if m.CalculateStep != "" {
		_ = json.Unmarshal([]byte(m.CalculateStep), &item.CalculateStep)
	}
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, m.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, m.ModifyTime)
	return
}

// FactorEdbSeriesCalculatePars 计算参数
type FactorEdbSeriesCalculatePars struct {
	Formula       interface{} `description:"N值/移动天数/指数修匀alpha值/计算公式等"`
	Calendar      string      `description:"公历/农历"`
	Frequency     string      `description:"需要转换的频度"`
	MoveType      int         `description:"移动方式: 1-领先(默认); 2-滞后"`
	MoveFrequency string      `description:"移动频度"`
	FromFrequency string      `description:"来源的频度"`
	Source        int         `description:"计算方式来源(不是指标来源)"`
	Sort          int         `description:"计算顺序"`
}

// CreateSeriesAndMapping 新增系列和指标关联
func (m *FactorEdbSeries) CreateSeriesAndMapping(item *FactorEdbSeries, mappings []*FactorEdbSeriesMapping) (seriesId int, err error) {
	if item == nil {
		err = fmt.Errorf("series is nil")
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	tx := o.Begin()
	if err = tx.Error; err != nil {
		err = fmt.Errorf("orm begin err: %v", err)
		return
	}
	defer func() {
		if err != nil {
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	// 创建系列
	err = tx.Create(item).Error
	if err != nil {
		err = fmt.Errorf("insert series err: %v", err)
		return
	}
	seriesId = item.FactorEdbSeriesId

	// 批量创建映射
	if len(mappings) > 0 {
		for _, v := range mappings {
			v.FactorEdbSeriesId = seriesId
		}
		err = tx.CreateInBatches(mappings, utils.MultiAddNum).Error
		if err != nil {
			err = fmt.Errorf("insert multi mapping err: %v", err)
			return
		}
	}
	return
}

// EditSeriesAndMapping 编辑系列和指标关联
func (m *FactorEdbSeries) EditSeriesAndMapping(item *FactorEdbSeries, mappings []*FactorEdbSeriesMapping, updateCols []string) (err error) {
	if item == nil {
		err = fmt.Errorf("series is nil")
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	tx := o.Begin()
	if err = tx.Error; err != nil {
		err = fmt.Errorf("orm begin err: %v", err)
		return
	}
	defer func() {
		if err != nil {
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	// 更新系列
	err = tx.Model(item).Select(updateCols).Updates(item).Error
	if err != nil {
		err = fmt.Errorf("update series err: %v", err)
		return
	}
	mappingOb := new(FactorEdbSeriesMapping)
	cond := fmt.Sprintf("%s = ?", mappingOb.Cols().FactorEdbSeriesId)
	pars := make([]interface{}, 0)
	pars = append(pars, item.FactorEdbSeriesId)
	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, mappingOb.TableName(), cond)
	err = tx.Exec(sql, pars...).Error
	if err != nil {
		err = fmt.Errorf("remove mapping err: %v", err)
		return
	}

	// 批量创建新映射
	if len(mappings) > 0 {
		for _, v := range mappings {
			v.FactorEdbSeriesId = item.FactorEdbSeriesId
		}
		err = tx.CreateInBatches(mappings, utils.MultiAddNum).Error
		if err != nil {
			err = fmt.Errorf("insert multi mapping err: %v", err)
			return
		}
	}
	return
}

// FactorEdbSeriesStepCalculateResp 批量计算响应
type FactorEdbSeriesStepCalculateResp struct {
	SeriesId int                                  `description:"多因子指标系列ID"`
	Fail     []FactorEdbSeriesStepCalculateResult `description:"计算失败的指标"`
	Success  []FactorEdbSeriesStepCalculateResult `description:"计算成功的指标"`
}

// FactorEdbSeriesStepCalculateResult 批量计算结果
type FactorEdbSeriesStepCalculateResult struct {
	EdbInfoId int    `description:"指标ID"`
	EdbCode   string `description:"指标编码"`
	Msg       string `description:"提示信息"`
	ErrMsg    string `description:"错误信息"`
}

// FactorEdbSeriesDetail 因子指标系列-详情
type FactorEdbSeriesDetail struct {
	*FactorEdbSeriesItem
	EdbMappings []*FactorEdbSeriesMappingItem
}

// FactorEdbSeriesCorrelationMatrixResp 因子指标系列-相关性矩阵响应
type FactorEdbSeriesCorrelationMatrixResp struct {
	Fail    []FactorEdbSeriesCorrelationMatrixItem `description:"计算失败的指标"`
	Success []FactorEdbSeriesCorrelationMatrixItem `description:"计算成功的指标"`
}

// FactorEdbSeriesCorrelationMatrixItem 因子指标系列-相关性矩阵信息
type FactorEdbSeriesCorrelationMatrixItem struct {
	SeriesId     int                                      `description:"因子指标系列ID"`
	EdbInfoId    int                                      `description:"指标ID"`
	EdbCode      string                                   `description:"指标编码"`
	EdbName      string                                   `description:"指标名称"`
	Values       []FactorEdbSeriesCorrelationMatrixValues `description:"X轴和Y轴数据"`
	Msg          string                                   `description:"提示信息"`
	ErrMsg       string                                   `description:"错误信息"`
	Used         bool                                     `description:"是否选中"`
	SourceName   string                                   `description:"指标来源名称"`
	SourceNameEn string                                   `description:"英文指标来源名称"`
}

// FactorEdbSeriesCorrelationMatrixValues 因子指标系列-相关性矩阵XY值
type FactorEdbSeriesCorrelationMatrixValues struct {
	XData int     `description:"X轴数据"`
	YData float64 `description:"Y轴数据"`
}

// FactorEdbSeriesCorrelationMatrixOrder 排序规则[0 1 2 3 -1 -2 -3]
type FactorEdbSeriesCorrelationMatrixOrder []FactorEdbSeriesCorrelationMatrixValues

func (a FactorEdbSeriesCorrelationMatrixOrder) Len() int {
	return len(a)
}

func (a FactorEdbSeriesCorrelationMatrixOrder) Swap(i, j int) {
	a[i], a[j] = a[j], a[i]
}

func (a FactorEdbSeriesCorrelationMatrixOrder) Less(i, j int) bool {
	// 非负数优先
	if a[i].XData >= 0 && a[j].XData < 0 {
		return true
	}
	if a[i].XData < 0 && a[j].XData >= 0 {
		return false
	}
	// 非负数升序排序
	if a[i].XData >= 0 {
		return a[i].XData < a[j].XData
	}
	// 负数按绝对值的降序排序（即数值的升序）
	return a[i].XData > a[j].XData
}

// RemoveSeriesAndMappingByFactorEdbSeriesId 删除系列和指标关联
func (m *FactorEdbSeries) RemoveSeriesAndMappingByFactorEdbSeriesId(factorEdbSeriesChartMapping *FactorEdbSeriesChartMapping) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	tx := o.Begin()
	if err = tx.Error; err != nil {
		err = fmt.Errorf("orm begin err: %v", err)
		return
	}
	defer func() {
		if err != nil {
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()
	
	factorEdbSeriesId := factorEdbSeriesChartMapping.FactorEdbSeriesId
	err = factorEdbSeriesChartMapping.Remove()
	if err != nil {
		err = fmt.Errorf("factorEdbSeriesChartMapping.delete err: %v", err)
		return
	}
	if factorEdbSeriesId == 0 {
		return
	}

	// 清除原指标关联
	seriesOb := new(FactorEdbSeries)
	cond := fmt.Sprintf("%s = ?", seriesOb.Cols().PrimaryId)
	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, seriesOb.TableName(), cond)
	err = tx.Exec(sql, factorEdbSeriesId).Error
	if err != nil {
		err = fmt.Errorf("remove FactorEdbSeries err: %v", err)
		return
	}

	// 清除原指标关联
	mappingOb := new(FactorEdbSeriesMapping)
	cond1 := fmt.Sprintf("%s = ?", mappingOb.Cols().FactorEdbSeriesId)
	sql = fmt.Sprintf(`DELETE FROM %s WHERE %s`, mappingOb.TableName(), cond1)
	err = tx.Exec(sql, factorEdbSeriesId).Error
	if err != nil {
		err = fmt.Errorf("remove mapping err: %v", err)
		return
	}

	// 删除原指标数据
	dataOb := new(FactorEdbSeriesCalculateDataQjjs)
	cond2 := fmt.Sprintf("%s = ?", dataOb.Cols().FactorEdbSeriesId)
	sql = fmt.Sprintf(`DELETE FROM %s WHERE %s`, dataOb.TableName(), cond2)
	err = tx.Exec(sql, factorEdbSeriesId).Error
	if err != nil {
		err = fmt.Errorf("remove mapping err: %v", err)
		return
	}
	return
}

// CalculateCorrelationMatrixPars 计算相关性矩阵参数
type CalculateCorrelationMatrixPars struct {
	BaseEdbInfoId int               `description:"标的指标ID"`
	SeriesIds     []int             `description:"系列IDs"`
	Correlation   CorrelationConfig `description:"相关性配置"`
}