157 lines
3.4 KiB
Go
157 lines
3.4 KiB
Go
package edgar
|
|
|
|
import (
|
|
"log"
|
|
"time"
|
|
|
|
"git.rouggy.com/rouggy/stockradar/internal/db"
|
|
)
|
|
|
|
type Poller struct {
|
|
db *db.DB
|
|
client *Client
|
|
ticker *time.Ticker
|
|
done chan struct{}
|
|
lastRun time.Time
|
|
}
|
|
|
|
func NewPoller(database *db.DB) *Poller {
|
|
return &Poller{
|
|
db: database,
|
|
client: New(),
|
|
done: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
func (p *Poller) Start() {
|
|
p.ticker = time.NewTicker(6 * time.Hour)
|
|
go func() {
|
|
if err := p.Sync(); err != nil {
|
|
log.Printf("edgar poller: initial sync: %v", err)
|
|
}
|
|
for {
|
|
select {
|
|
case <-p.ticker.C:
|
|
if err := p.Sync(); err != nil {
|
|
log.Printf("edgar poller: sync: %v", err)
|
|
}
|
|
case <-p.done:
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
func (p *Poller) Stop() {
|
|
if p.ticker != nil {
|
|
p.ticker.Stop()
|
|
}
|
|
close(p.done)
|
|
}
|
|
|
|
// SyncTicker récupère les insider trades et les events 8-K pour un ticker spécifique.
|
|
func (p *Poller) SyncTicker(sym string) error {
|
|
trades, err := p.client.RecentInsiderBuys(sym)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, t := range trades {
|
|
p.insertTrade(t)
|
|
}
|
|
events, _ := p.client.Recent8KEvents(sym)
|
|
for _, e := range events {
|
|
p.insertEvent(e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// HasRecentCEOChange retourne true si un 8-K Item 5.02 a été déposé dans les N derniers jours.
|
|
func (p *Poller) HasRecentCEOChange(ticker string, days int) bool {
|
|
cutoff := time.Now().AddDate(0, 0, -days).Format("2006-01-02")
|
|
var count int
|
|
p.db.QueryRow(`
|
|
SELECT COUNT(*) FROM company_events
|
|
WHERE ticker=? AND event_type='ceo_change' AND filing_date >= ?
|
|
`, ticker, cutoff).Scan(&count)
|
|
return count > 0
|
|
}
|
|
|
|
func (p *Poller) Sync() error {
|
|
tickers, err := p.watchlistTickers()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(tickers) == 0 {
|
|
return nil
|
|
}
|
|
|
|
log.Printf("edgar: scanning %d tickers for insider trades…", len(tickers))
|
|
total := 0
|
|
|
|
for _, sym := range tickers {
|
|
trades, err := p.client.RecentInsiderBuys(sym)
|
|
if err != nil {
|
|
log.Printf("edgar: %s: %v", sym, err)
|
|
} else {
|
|
for _, t := range trades {
|
|
if p.insertTrade(t) {
|
|
total++
|
|
}
|
|
}
|
|
}
|
|
events, _ := p.client.Recent8KEvents(sym)
|
|
for _, e := range events {
|
|
p.insertEvent(e)
|
|
}
|
|
time.Sleep(500 * time.Millisecond) // respecter le rate limit EDGAR
|
|
}
|
|
|
|
p.lastRun = time.Now()
|
|
if total > 0 {
|
|
log.Printf("edgar: sync done — %d nouveaux insider trades", total)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Poller) watchlistTickers() ([]string, error) {
|
|
rows, err := p.db.Query(`SELECT ticker FROM watchlist WHERE active=1`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var tickers []string
|
|
for rows.Next() {
|
|
var t string
|
|
if err := rows.Scan(&t); err != nil {
|
|
return nil, err
|
|
}
|
|
tickers = append(tickers, t)
|
|
}
|
|
return tickers, nil
|
|
}
|
|
|
|
func (p *Poller) insertEvent(e CompanyEvent) {
|
|
p.db.Exec(`
|
|
INSERT OR IGNORE INTO company_events
|
|
(ticker, event_type, title, accession_no, filing_date, filing_url)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`, e.Ticker, e.EventType, e.Title, e.AccessionNo, e.FilingDate, e.FilingURL)
|
|
}
|
|
|
|
func (p *Poller) insertTrade(t InsiderTrade) bool {
|
|
res, err := p.db.Exec(`
|
|
INSERT OR IGNORE INTO insider_trades
|
|
(ticker, insider_name, insider_title, transaction_code,
|
|
shares, price, total_value, transaction_date, accession_no, filing_url)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`, t.Ticker, t.InsiderName, t.InsiderTitle, t.TransactionCode,
|
|
t.Shares, t.PricePerShare, t.TotalValue, t.TransactionDate,
|
|
t.AccessionNo, t.FilingURL)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
n, _ := res.RowsAffected()
|
|
return n > 0
|
|
}
|