ajoute snapshot
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
This commit is contained in:
parent
c73021a14f
commit
0f2d7126eb
GPG key ID:
4406BBBF8845D632
11 changed files with 862 additions and 19 deletions
271
internal/store/snapshot.go
Normal file
271
internal/store/snapshot.go
Normal file
|
|
@ -0,0 +1,271 @@
|
|||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
type PositionRow struct {
|
||||
InstrumentID int32 `json:"instrument_id"`
|
||||
InstrumentType string `json:"instrument_type"`
|
||||
Quantite float64 `json:"quantite"`
|
||||
}
|
||||
|
||||
type PositionSnapshot struct {
|
||||
Date time.Time
|
||||
AccountID int32
|
||||
InstrumentID int32
|
||||
Quantite float64
|
||||
PRU *float64
|
||||
PrixCloture *float64
|
||||
Valeur *float64
|
||||
}
|
||||
|
||||
type AccountSnapshot struct {
|
||||
Date time.Time
|
||||
AccountID int32
|
||||
Valeur float64
|
||||
}
|
||||
|
||||
// ListAllAccountIDs retourne tous les comptes (maîtres + enveloppes).
|
||||
func (s *Store) ListAllAccountIDs(ctx context.Context) ([]int32, error) {
|
||||
rows, err := s.pool.Query(ctx, `SELECT id FROM account ORDER BY id`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var ids []int32
|
||||
for rows.Next() {
|
||||
var id int32
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
return ids, rows.Err()
|
||||
}
|
||||
|
||||
// GetLatestSnapshotDate retourne la date du snapshot le plus récent strictement
|
||||
// antérieur à before. Retourne (zero, false, nil) si aucun snapshot n'existe.
|
||||
// On utilise account_snapshot comme marqueur de "jour déjà calculé" car il
|
||||
// contient toujours une ligne même pour un compte à solde nul.
|
||||
func (s *Store) GetLatestSnapshotDate(ctx context.Context, accountID int32, before time.Time) (time.Time, bool, error) {
|
||||
var t *time.Time
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT MAX(date) FROM account_snapshot
|
||||
WHERE account_id = $1 AND date < $2::date
|
||||
`, accountID, before).Scan(&t)
|
||||
if err != nil || t == nil {
|
||||
return time.Time{}, false, err
|
||||
}
|
||||
return *t, true, nil
|
||||
}
|
||||
|
||||
// GetBasePositions retourne les positions d'un compte à une date de snapshot
|
||||
// existante, enrichies du type d'instrument pour le fallback de prix.
|
||||
func (s *Store) GetBasePositions(ctx context.Context, accountID int32, date time.Time) ([]PositionRow, error) {
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT ps.instrument_id, i.type AS instrument_type, ps.quantite
|
||||
FROM position_snapshot ps
|
||||
JOIN instrument i ON i.id = ps.instrument_id
|
||||
WHERE ps.account_id = $1 AND ps.date = $2::date
|
||||
`, accountID, date)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return pgx.CollectRows(rows, pgx.RowToStructByName[PositionRow])
|
||||
}
|
||||
|
||||
// ComputeDeltas calcule les variations nettes par instrument pour un compte
|
||||
// entre fromExclusive (exclu) et toInclusive (inclus).
|
||||
// Toutes les transactions sont comptées quelle que soit leur validation :
|
||||
// le solde reflète l'état envisagé complet (passé confirmé + prévisionnel).
|
||||
// Passer time.Time{} comme fromExclusive couvre toutes les transactions.
|
||||
func (s *Store) ComputeDeltas(ctx context.Context, accountID int32, fromExclusive, toInclusive time.Time) ([]PositionRow, error) {
|
||||
from := fromExclusive
|
||||
if from.IsZero() {
|
||||
from = time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC)
|
||||
}
|
||||
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
WITH flows AS (
|
||||
SELECT instrument_dest_id AS instrument_id, quantite_dest AS delta
|
||||
FROM transaction
|
||||
WHERE account_dest_id = $1
|
||||
AND date > $2::date AND date <= $3::date
|
||||
UNION ALL
|
||||
SELECT instrument_source_id, -quantite_source
|
||||
FROM transaction
|
||||
WHERE account_source_id = $1
|
||||
AND date > $2::date AND date <= $3::date
|
||||
)
|
||||
SELECT f.instrument_id, i.type AS instrument_type, SUM(f.delta) AS quantite
|
||||
FROM flows f
|
||||
JOIN instrument i ON i.id = f.instrument_id
|
||||
GROUP BY f.instrument_id, i.type
|
||||
`, accountID, from, toInclusive)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return pgx.CollectRows(rows, pgx.RowToStructByName[PositionRow])
|
||||
}
|
||||
|
||||
// AccountSnapshotRow représente une ligne de account_snapshot pour la restitution.
|
||||
type AccountSnapshotRow struct {
|
||||
Date string `json:"date"`
|
||||
Valeur float64 `json:"valeur"`
|
||||
}
|
||||
|
||||
// PositionSnapshotRow représente une ligne de position_snapshot pour la restitution.
|
||||
type PositionSnapshotRow struct {
|
||||
Date string `json:"date"`
|
||||
InstrumentID int32 `json:"instrument_id"`
|
||||
Quantite float64 `json:"quantite"`
|
||||
PRU *float64 `json:"pru,omitempty"`
|
||||
PrixCloture *float64 `json:"prix_cloture,omitempty"`
|
||||
Valeur *float64 `json:"valeur,omitempty"`
|
||||
}
|
||||
|
||||
// ListAccountSnapshots retourne les snapshots agrégés d'un compte entre from et to.
|
||||
// Si from est zero, pas de borne inférieure. Si to est zero, pas de borne supérieure.
|
||||
func (s *Store) ListAccountSnapshots(ctx context.Context, accountID int32, from, to time.Time) ([]AccountSnapshotRow, error) {
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT date::text, valeur
|
||||
FROM account_snapshot
|
||||
WHERE account_id = $1
|
||||
AND ($2::date IS NULL OR date >= $2::date)
|
||||
AND ($3::date IS NULL OR date <= $3::date)
|
||||
ORDER BY date
|
||||
`, accountID, nullableDate(from), nullableDate(to))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return pgx.CollectRows(rows, pgx.RowToStructByName[AccountSnapshotRow])
|
||||
}
|
||||
|
||||
// ListPositionSnapshots retourne les positions détaillées d'un compte entre from et to.
|
||||
// Si from est zero, pas de borne inférieure. Si to est zero, pas de borne supérieure.
|
||||
func (s *Store) ListPositionSnapshots(ctx context.Context, accountID int32, from, to time.Time) ([]PositionSnapshotRow, error) {
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT date::text, instrument_id, quantite, pru, prix_cloture, valeur
|
||||
FROM position_snapshot
|
||||
WHERE account_id = $1
|
||||
AND ($2::date IS NULL OR date >= $2::date)
|
||||
AND ($3::date IS NULL OR date <= $3::date)
|
||||
ORDER BY date, instrument_id
|
||||
`, accountID, nullableDate(from), nullableDate(to))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return pgx.CollectRows(rows, pgx.RowToStructByName[PositionSnapshotRow])
|
||||
}
|
||||
|
||||
// nullableDate convertit time.Time{} en nil pour les paramètres SQL optionnels.
|
||||
func nullableDate(t time.Time) any {
|
||||
if t.IsZero() {
|
||||
return nil
|
||||
}
|
||||
return t
|
||||
}
|
||||
|
||||
// GetPriceAt retourne le dernier prix connu pour un instrument à une date donnée.
|
||||
// Retourne (0, false, nil) si aucun prix n'est trouvé.
|
||||
func (s *Store) GetPriceAt(ctx context.Context, instrumentID int32, date time.Time) (float64, bool, error) {
|
||||
var prix float64
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT prix FROM price_history
|
||||
WHERE instrument_id = $1 AND fetched_at::date <= $2::date
|
||||
ORDER BY fetched_at DESC
|
||||
LIMIT 1
|
||||
`, instrumentID, date).Scan(&prix)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return 0, false, nil
|
||||
}
|
||||
if err != nil {
|
||||
return 0, false, err
|
||||
}
|
||||
return prix, true, nil
|
||||
}
|
||||
|
||||
func (s *Store) UpsertPositionSnapshot(ctx context.Context, snap PositionSnapshot) error {
|
||||
_, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO position_snapshot (date, account_id, instrument_id, quantite, pru, prix_cloture, valeur)
|
||||
VALUES ($1::date, $2, $3, $4, $5, $6, $7)
|
||||
ON CONFLICT (date, account_id, instrument_id) DO UPDATE SET
|
||||
quantite = EXCLUDED.quantite,
|
||||
pru = EXCLUDED.pru,
|
||||
prix_cloture = EXCLUDED.prix_cloture,
|
||||
valeur = EXCLUDED.valeur
|
||||
`, snap.Date, snap.AccountID, snap.InstrumentID,
|
||||
snap.Quantite, snap.PRU, snap.PrixCloture, snap.Valeur)
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Store) UpsertAccountSnapshot(ctx context.Context, snap AccountSnapshot) error {
|
||||
_, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO account_snapshot (date, account_id, valeur)
|
||||
VALUES ($1::date, $2, $3)
|
||||
ON CONFLICT (date, account_id) DO UPDATE SET valeur = EXCLUDED.valeur
|
||||
`, snap.Date, snap.AccountID, snap.Valeur)
|
||||
return err
|
||||
}
|
||||
|
||||
// ── Invalidation ─────────────────────────────────────────────────────────────
|
||||
|
||||
type Invalidation struct {
|
||||
AccountID int32
|
||||
RecomputeFrom time.Time
|
||||
}
|
||||
|
||||
// InvalidateSnapshot marque un compte comme nécessitant un recalcul depuis date.
|
||||
// Conserve le MIN si une invalidation antérieure existe déjà.
|
||||
func (s *Store) InvalidateSnapshot(ctx context.Context, accountID int32, from time.Time) error {
|
||||
_, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO account_snapshot_invalidation (account_id, recompute_from)
|
||||
VALUES ($1, $2::date)
|
||||
ON CONFLICT (account_id) DO UPDATE
|
||||
SET recompute_from = LEAST(account_snapshot_invalidation.recompute_from, EXCLUDED.recompute_from)
|
||||
`, accountID, from)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetInvalidations retourne tous les comptes en attente de recalcul.
|
||||
func (s *Store) GetInvalidations(ctx context.Context) ([]Invalidation, error) {
|
||||
rows, err := s.pool.Query(ctx,
|
||||
`SELECT account_id, recompute_from FROM account_snapshot_invalidation ORDER BY account_id`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var out []Invalidation
|
||||
for rows.Next() {
|
||||
var inv Invalidation
|
||||
if err := rows.Scan(&inv.AccountID, &inv.RecomputeFrom); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, inv)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// ClearInvalidation supprime le flag d'invalidation une fois le recalcul terminé.
|
||||
func (s *Store) ClearInvalidation(ctx context.Context, accountID int32) error {
|
||||
_, err := s.pool.Exec(ctx,
|
||||
`DELETE FROM account_snapshot_invalidation WHERE account_id = $1`, accountID)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetInvalidation retourne l'invalidation d'un compte spécifique, si elle existe.
|
||||
func (s *Store) GetInvalidation(ctx context.Context, accountID int32) (Invalidation, bool, error) {
|
||||
var inv Invalidation
|
||||
err := s.pool.QueryRow(ctx,
|
||||
`SELECT account_id, recompute_from FROM account_snapshot_invalidation WHERE account_id = $1`,
|
||||
accountID).Scan(&inv.AccountID, &inv.RecomputeFrom)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return Invalidation{}, false, nil
|
||||
}
|
||||
return inv, err == nil, err
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue