156 lines
3.1 KiB
Go
156 lines
3.1 KiB
Go
package etoro
|
|
|
|
import (
|
|
"log"
|
|
"sync"
|
|
"time"
|
|
|
|
"git.rouggy.com/rouggy/stockradar/internal/db"
|
|
)
|
|
|
|
type SyncStatus struct {
|
|
Syncing bool `json:"syncing"`
|
|
Progress int `json:"progress"`
|
|
Total int `json:"total"`
|
|
Count int `json:"count"`
|
|
LastSync time.Time `json:"last_sync"`
|
|
LastError string `json:"last_error,omitempty"`
|
|
}
|
|
|
|
type Poller struct {
|
|
db *db.DB
|
|
client *Client
|
|
ticker *time.Ticker
|
|
done chan struct{}
|
|
|
|
mu sync.Mutex
|
|
syncing bool
|
|
progress int
|
|
total int
|
|
lastSync time.Time
|
|
lastError string
|
|
}
|
|
|
|
func NewPoller(database *db.DB) *Poller {
|
|
return &Poller{
|
|
db: database,
|
|
client: New(),
|
|
done: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
func (p *Poller) Start() {
|
|
p.ticker = time.NewTicker(24 * time.Hour)
|
|
go func() {
|
|
if err := p.Sync(); err != nil {
|
|
log.Printf("etoro poller: initial sync: %v", err)
|
|
}
|
|
for {
|
|
select {
|
|
case <-p.ticker.C:
|
|
if err := p.Sync(); err != nil {
|
|
log.Printf("etoro poller: sync: %v", err)
|
|
}
|
|
case <-p.done:
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
func (p *Poller) Stop() {
|
|
if p.ticker != nil {
|
|
p.ticker.Stop()
|
|
}
|
|
close(p.done)
|
|
}
|
|
|
|
func (p *Poller) Status() SyncStatus {
|
|
p.mu.Lock()
|
|
defer p.mu.Unlock()
|
|
return SyncStatus{
|
|
Syncing: p.syncing,
|
|
Progress: p.progress,
|
|
Total: p.total,
|
|
Count: p.dbCount(),
|
|
LastSync: p.lastSync,
|
|
LastError: p.lastError,
|
|
}
|
|
}
|
|
|
|
func (p *Poller) Sync() error {
|
|
p.mu.Lock()
|
|
if p.syncing {
|
|
p.mu.Unlock()
|
|
return nil // déjà en cours
|
|
}
|
|
p.syncing = true
|
|
p.progress = 0
|
|
p.total = 0
|
|
p.lastError = ""
|
|
p.mu.Unlock()
|
|
|
|
defer func() {
|
|
p.mu.Lock()
|
|
p.syncing = false
|
|
p.lastSync = time.Now()
|
|
p.mu.Unlock()
|
|
}()
|
|
|
|
log.Println("etoro: fetching instruments…")
|
|
stocks, err := p.client.FetchStocks()
|
|
if err != nil {
|
|
p.mu.Lock()
|
|
p.lastError = err.Error()
|
|
p.mu.Unlock()
|
|
log.Printf("etoro: fetch error: %v", err)
|
|
return err
|
|
}
|
|
|
|
p.mu.Lock()
|
|
p.total = len(stocks)
|
|
p.mu.Unlock()
|
|
|
|
log.Printf("etoro: %d stocks à synchroniser", len(stocks))
|
|
|
|
inserted := 0
|
|
for i, s := range stocks {
|
|
_, err := p.db.Exec(`
|
|
INSERT INTO instruments (instrument_id, ticker, name, exchange_id, asset_class_id, synced_at)
|
|
VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
|
|
ON CONFLICT(instrument_id) DO UPDATE SET
|
|
ticker = excluded.ticker,
|
|
name = excluded.name,
|
|
exchange_id = excluded.exchange_id,
|
|
synced_at = CURRENT_TIMESTAMP
|
|
`, s.InstrumentID, s.SymbolFull, s.InstrumentDisplayName,
|
|
s.StockExchangeID, s.InstrumentTypeID)
|
|
if err == nil {
|
|
inserted++
|
|
}
|
|
|
|
if (i+1)%100 == 0 || i+1 == len(stocks) {
|
|
p.mu.Lock()
|
|
p.progress = i + 1
|
|
p.mu.Unlock()
|
|
log.Printf("etoro: %d/%d instruments traités", i+1, len(stocks))
|
|
}
|
|
}
|
|
|
|
log.Printf("etoro: sync terminée — %d/%d instruments en DB", inserted, len(stocks))
|
|
return nil
|
|
}
|
|
|
|
func (p *Poller) dbCount() int {
|
|
var n int
|
|
p.db.QueryRow(`SELECT COUNT(*) FROM instruments`).Scan(&n)
|
|
return n
|
|
}
|
|
|
|
// IsEtoro vérifie si un ticker est dans l'univers eToro.
|
|
func IsEtoro(database *db.DB, ticker string) bool {
|
|
var count int
|
|
database.QueryRow(`SELECT COUNT(*) FROM instruments WHERE ticker = ?`, ticker).Scan(&count)
|
|
return count > 0
|
|
}
|