311 lines
8.4 KiB
Go
311 lines
8.4 KiB
Go
package storage
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"time"
|
|
|
|
"git.apinb.com/quant/collector/models"
|
|
"git.apinb.com/quant/collector/types"
|
|
"gorm.io/driver/postgres"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/logger"
|
|
)
|
|
|
|
// Storage 数据库存储器
|
|
type Storage struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
// NewStorage 创建新的数据库连接
|
|
func NewStorage(connStr string) (*Storage, error) {
|
|
// 配置GORM日志
|
|
newLogger := logger.New(
|
|
log.New(log.Writer(), "\r\n", log.LstdFlags),
|
|
logger.Config{
|
|
SlowThreshold: time.Second,
|
|
LogLevel: logger.Warn,
|
|
IgnoreRecordNotFoundError: true,
|
|
Colorful: true,
|
|
},
|
|
)
|
|
|
|
db, err := gorm.Open(postgres.Open(connStr), &gorm.Config{
|
|
Logger: newLogger,
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("打开数据库连接失败: %w", err)
|
|
}
|
|
|
|
// 获取底层的sql.DB以设置连接池
|
|
sqlDB, err := db.DB()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("获取数据库实例失败: %w", err)
|
|
}
|
|
|
|
// 设置连接池参数
|
|
sqlDB.SetMaxOpenConns(25)
|
|
sqlDB.SetMaxIdleConns(5)
|
|
sqlDB.SetConnMaxLifetime(5 * time.Minute)
|
|
|
|
log.Println("数据库连接成功")
|
|
return &Storage{db: db}, nil
|
|
}
|
|
|
|
// Close 关闭数据库连接
|
|
func (s *Storage) Close() error {
|
|
if s.db != nil {
|
|
sqlDB, err := s.db.DB()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return sqlDB.Close()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// AutoMigrate 自动迁移数据库表结构
|
|
func (s *Storage) AutoMigrate() error {
|
|
log.Println("开始自动迁移数据库表结构...")
|
|
|
|
err := s.db.AutoMigrate(
|
|
&models.CollectorAssets{},
|
|
&models.CollectorOrder{},
|
|
&models.CollectorPosition{},
|
|
&models.CollectorTick{},
|
|
&models.CollectorLog{},
|
|
)
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("自动迁移失败: %w", err)
|
|
}
|
|
|
|
log.Println("数据库表结构迁移完成")
|
|
return nil
|
|
}
|
|
|
|
// SaveStatus 保存完整状态数据(使用事务)
|
|
func (s *Storage) SaveStatus(status *types.Status, dataHash string) error {
|
|
// 验证必要字段 - AccountID是所有Upsert的共同条件
|
|
if status.Data.Assets.AccountID == "" {
|
|
return fmt.Errorf("账户ID不能为空")
|
|
}
|
|
|
|
return s.db.Transaction(func(tx *gorm.DB) error {
|
|
// 计算Ymd (年月日数字格式,如20260407)
|
|
now := time.Now()
|
|
ymd := now.Year()*10000 + int(now.Month())*100 + now.Day()
|
|
|
|
// 保存资产快照 (先查询后更新/插入)
|
|
var existingAsset models.CollectorAssets
|
|
err := tx.Where("account_id = ? AND ymd = ?", status.Data.Assets.AccountID, ymd).First(&existingAsset).Error
|
|
|
|
asset := models.CollectorAssets{
|
|
AccountID: status.Data.Assets.AccountID,
|
|
Ymd: ymd,
|
|
Cash: status.Data.Assets.Cash,
|
|
FrozenCash: status.Data.Assets.FrozenCash,
|
|
MarketValue: status.Data.Assets.MarketValue,
|
|
Profit: status.Data.Assets.Profit,
|
|
TotalAsset: status.Data.Assets.TotalAsset,
|
|
DataHash: dataHash,
|
|
CollectedAt: now,
|
|
}
|
|
|
|
if err == gorm.ErrRecordNotFound {
|
|
// 记录不存在，插入新记录
|
|
if err := tx.Create(&asset).Error; err != nil {
|
|
return fmt.Errorf("插入资产快照失败: %w", err)
|
|
}
|
|
} else if err != nil {
|
|
// 查询出错
|
|
return fmt.Errorf("查询资产快照失败: %w", err)
|
|
} else {
|
|
// 记录存在，更新现有记录
|
|
asset.ID = existingAsset.ID
|
|
if err := tx.Save(&asset).Error; err != nil {
|
|
return fmt.Errorf("更新资产快照失败: %w", err)
|
|
}
|
|
}
|
|
|
|
// 批量保存订单 (先查询后更新/插入)
|
|
if len(status.Data.Orders) > 0 {
|
|
for _, order := range status.Data.Orders {
|
|
// 验证必要条件: OrderID和StockCode
|
|
if order.OrderID == 0 {
|
|
continue
|
|
}
|
|
if order.StockCode == "" {
|
|
continue
|
|
}
|
|
var open_price float64
|
|
var info types.OrderInfo
|
|
err = json.Unmarshal([]byte(order.OrderRemark), &info)
|
|
if err == nil {
|
|
open_price = info.Op
|
|
}
|
|
|
|
// 查询是否存在
|
|
var existingOrder models.CollectorOrder
|
|
err := tx.Where("account_id = ? AND order_id = ? AND ymd = ?",
|
|
status.Data.Assets.AccountID, order.OrderID, ymd).First(&existingOrder).Error
|
|
|
|
orderRecord := models.CollectorOrder{
|
|
OrderID: order.OrderID,
|
|
AccountID: status.Data.Assets.AccountID,
|
|
StockCode: order.StockCode,
|
|
Ymd: ymd,
|
|
Price: order.Price,
|
|
Volume: order.Volume,
|
|
OpenPrice: open_price,
|
|
TradedPrice: order.TradedPrice,
|
|
TradedVolume: order.TradedVolume,
|
|
OrderStatus: order.OrderStatus,
|
|
OrderTime: order.OrderTime,
|
|
OrderRemark: order.OrderRemark,
|
|
DataHash: dataHash,
|
|
CollectedAt: now,
|
|
}
|
|
|
|
if err == gorm.ErrRecordNotFound {
|
|
// 记录不存在，插入新记录
|
|
if err := tx.Create(&orderRecord).Error; err != nil {
|
|
return fmt.Errorf("插入订单失败: %w", err)
|
|
}
|
|
} else if err != nil {
|
|
// 查询出错
|
|
return fmt.Errorf("查询订单失败: %w", err)
|
|
} else {
|
|
// 记录存在，更新现有记录
|
|
orderRecord.ID = existingOrder.ID
|
|
if err := tx.Save(&orderRecord).Error; err != nil {
|
|
return fmt.Errorf("更新订单失败: %w", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 批量保存持仓 (先查询后更新/插入)
|
|
if len(status.Data.Positions) > 0 {
|
|
for _, pos := range status.Data.Positions {
|
|
// 验证必要条件: Code
|
|
if pos.Code == "" {
|
|
continue
|
|
}
|
|
|
|
// 查询是否存在
|
|
var existingPosition models.CollectorPosition
|
|
err := tx.Where("account_id = ? AND code = ? AND ymd = ?",
|
|
status.Data.Assets.AccountID, pos.Code, ymd).First(&existingPosition).Error
|
|
|
|
positionRecord := models.CollectorPosition{
|
|
AccountID: status.Data.Assets.AccountID,
|
|
Code: pos.Code,
|
|
Ymd: ymd,
|
|
Volume: pos.Volume,
|
|
CanUseVolume: pos.CanUseVolume,
|
|
FrozenVolume: pos.FrozenVolume,
|
|
AvgPrice: pos.AvgPrice,
|
|
OpenPrice: pos.OpenPrice,
|
|
CurrentPrice: pos.CurrentPrice,
|
|
MarketValue: pos.MarketValue,
|
|
Profit: pos.Profit,
|
|
ProfitRate: pos.ProfitRate,
|
|
MinProfitRate: pos.MinProfitRate,
|
|
DataHash: dataHash,
|
|
CollectedAt: now,
|
|
}
|
|
|
|
if err == gorm.ErrRecordNotFound {
|
|
// 记录不存在，插入新记录
|
|
if err := tx.Create(&positionRecord).Error; err != nil {
|
|
return fmt.Errorf("插入持仓失败: %w", err)
|
|
}
|
|
} else if err != nil {
|
|
// 查询出错
|
|
return fmt.Errorf("查询持仓失败: %w", err)
|
|
} else {
|
|
// 记录存在，更新现有记录
|
|
positionRecord.ID = existingPosition.ID
|
|
if err := tx.Save(&positionRecord).Error; err != nil {
|
|
return fmt.Errorf("更新持仓失败: %w", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 批量保存行情数据 (先查询后更新/插入)
|
|
if len(status.Data.TickData) > 0 {
|
|
for code, tick := range status.Data.TickData {
|
|
// 验证必要条件: StockCode
|
|
if code == "" {
|
|
continue
|
|
}
|
|
|
|
// 查询是否存在
|
|
var existingTick models.CollectorTick
|
|
err := tx.Where("stock_code = ? AND ymd = ?", code, ymd).First(&existingTick).Error
|
|
|
|
tickRecord := models.CollectorTick{
|
|
StockCode: code,
|
|
Ymd: ymd,
|
|
LastPrice: tick.LastPrice,
|
|
Open: tick.Open,
|
|
High: tick.High,
|
|
Low: tick.Low,
|
|
LastClose: tick.LastClose,
|
|
Volume: tick.Volume,
|
|
Amount: tick.Amount,
|
|
PVolume: tick.PVolume,
|
|
Time: tick.Time,
|
|
TimeTag: tick.TimeTag,
|
|
StockStatus: tick.StockStatus,
|
|
DataHash: dataHash,
|
|
CollectedAt: now,
|
|
}
|
|
|
|
if err == gorm.ErrRecordNotFound {
|
|
// 记录不存在，插入新记录
|
|
if err := tx.Create(&tickRecord).Error; err != nil {
|
|
return fmt.Errorf("插入行情数据失败: %w", err)
|
|
}
|
|
} else if err != nil {
|
|
// 查询出错
|
|
return fmt.Errorf("查询行情数据失败: %w", err)
|
|
} else {
|
|
// 记录存在，更新现有记录
|
|
tickRecord.ID = existingTick.ID
|
|
if err := tx.Save(&tickRecord).Error; err != nil {
|
|
return fmt.Errorf("更新行情数据失败: %w", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// SaveCollectionLog 保存采集日志
|
|
func (s *Storage) SaveCollectionLog(dataHash string, ymd int, hasChanged bool, statusMessage string) error {
|
|
log := models.CollectorLog{
|
|
DataHash: dataHash,
|
|
Ymd: ymd,
|
|
HasChanged: hasChanged,
|
|
StatusMessage: statusMessage,
|
|
CollectedAt: time.Now(),
|
|
}
|
|
|
|
if err := s.db.Create(&log).Error; err != nil {
|
|
return fmt.Errorf("保存采集日志失败: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetDB 获取GORM DB实例(用于高级查询)
|
|
func (s *Storage) GetDB() *gorm.DB {
|
|
return s.db
|
|
}
|