aitrade/pkg/db/whitelist.go

package db

import (
	"context"
	"fmt"
	"time"

	"github.com/pheinrich/aitrade/pkg/model"
)

type WhitelistRepository struct {
	db Database
}

func NewWhitelistRepository(db Database) *WhitelistRepository {
	return &WhitelistRepository{db: db}
}

func (r *WhitelistRepository) Create(ctx context.Context, entry *model.WhitelistEntry) error {
	query := `
		INSERT INTO whitelist (symbol, name, wkn, isin, enabled, notes, created_at, updated_at)
		VALUES (?, ?, ?, ?, ?, ?, ?, ?)
	`

	now := time.Now()
	result, err := r.db.ExecContext(ctx, query,
		entry.Symbol,
		entry.Name,
		entry.WKN,
		entry.ISIN,
		entry.Enabled,
		entry.Notes,
		now,
		now,
	)
	if err != nil {
		return fmt.Errorf("failed to insert whitelist entry: %w", err)
	}

	id, err := result.LastInsertId()
	if err != nil {
		return fmt.Errorf("failed to get last insert id: %w", err)
	}

	entry.ID = id
	entry.CreatedAt = now
	entry.UpdatedAt = now
	return nil
}

func (r *WhitelistRepository) Update(ctx context.Context, entry *model.WhitelistEntry) error {
	query := `
		UPDATE whitelist SET
			name = ?,
			wkn = ?,
			isin = ?,
			enabled = ?,
			notes = ?,
			updated_at = ?
		WHERE id = ?
	`

	now := time.Now()
	_, err := r.db.ExecContext(ctx, query,
		entry.Name,
		entry.WKN,
		entry.ISIN,
		entry.Enabled,
		entry.Notes,
		now,
		entry.ID,
	)

	if err != nil {
		return fmt.Errorf("failed to update whitelist entry: %w", err)
	}

	entry.UpdatedAt = now
	return nil
}

func (r *WhitelistRepository) Delete(ctx context.Context, id int64) error {
	query := `DELETE FROM whitelist WHERE id = ?`

	_, err := r.db.ExecContext(ctx, query, id)
	if err != nil {
		return fmt.Errorf("failed to delete whitelist entry: %w", err)
	}

	return nil
}

func (r *WhitelistRepository) GetByID(ctx context.Context, id int64) (*model.WhitelistEntry, error) {
	query := `
		SELECT id, symbol, name, wkn, isin, enabled, created_at, updated_at, notes
		FROM whitelist
		WHERE id = ?
	`

	var entry model.WhitelistEntry
	err := r.db.QueryRowContext(ctx, query, id).Scan(
		&entry.ID,
		&entry.Symbol,
		&entry.Name,
		&entry.WKN,
		&entry.ISIN,
		&entry.Enabled,
		&entry.CreatedAt,
		&entry.UpdatedAt,
		&entry.Notes,
	)

	if err != nil {
		return nil, fmt.Errorf("failed to get whitelist entry: %w", err)
	}

	return &entry, nil
}

func (r *WhitelistRepository) GetBySymbol(ctx context.Context, symbol string) (*model.WhitelistEntry, error) {
	query := `
		SELECT id, symbol, name, wkn, isin, enabled, created_at, updated_at, notes
		FROM whitelist
		WHERE symbol = ?
	`

	var entry model.WhitelistEntry
	err := r.db.QueryRowContext(ctx, query, symbol).Scan(
		&entry.ID,
		&entry.Symbol,
		&entry.Name,
		&entry.WKN,
		&entry.ISIN,
		&entry.Enabled,
		&entry.CreatedAt,
		&entry.UpdatedAt,
		&entry.Notes,
	)

	if err != nil {
		return nil, fmt.Errorf("failed to get whitelist entry: %w", err)
	}

	return &entry, nil
}

func (r *WhitelistRepository) GetAll(ctx context.Context) ([]*model.WhitelistEntry, error) {
	query := `
		SELECT id, symbol, name, wkn, isin, enabled, created_at, updated_at, notes
		FROM whitelist
		ORDER BY symbol ASC
	`

	rows, err := r.db.QueryContext(ctx, query)
	if err != nil {
		return nil, fmt.Errorf("failed to query whitelist: %w", err)
	}
	defer rows.Close()

	var entries []*model.WhitelistEntry
	for rows.Next() {
		var entry model.WhitelistEntry
		if err := rows.Scan(
			&entry.ID,
			&entry.Symbol,
			&entry.Name,
			&entry.WKN,
			&entry.ISIN,
			&entry.Enabled,
			&entry.CreatedAt,
			&entry.UpdatedAt,
			&entry.Notes,
		); err != nil {
			return nil, fmt.Errorf("failed to scan whitelist entry: %w", err)
		}
		entries = append(entries, &entry)
	}

	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("error iterating whitelist rows: %w", err)
	}

	return entries, nil
}

func (r *WhitelistRepository) GetEnabled(ctx context.Context) ([]*model.WhitelistEntry, error) {
	query := `
		SELECT id, symbol, name, wkn, isin, enabled, created_at, updated_at, notes
		FROM whitelist
		WHERE enabled = TRUE
		ORDER BY symbol ASC
	`

	rows, err := r.db.QueryContext(ctx, query)
	if err != nil {
		return nil, fmt.Errorf("failed to query enabled whitelist: %w", err)
	}
	defer rows.Close()

	var entries []*model.WhitelistEntry
	for rows.Next() {
		var entry model.WhitelistEntry
		if err := rows.Scan(
			&entry.ID,
			&entry.Symbol,
			&entry.Name,
			&entry.WKN,
			&entry.ISIN,
			&entry.Enabled,
			&entry.CreatedAt,
			&entry.UpdatedAt,
			&entry.Notes,
		); err != nil {
			return nil, fmt.Errorf("failed to scan whitelist entry: %w", err)
		}
		entries = append(entries, &entry)
	}

	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("error iterating whitelist rows: %w", err)
	}

	return entries, nil
}

func (r *WhitelistRepository) IsSymbolWhitelisted(ctx context.Context, symbol string) (bool, error) {
	query := `SELECT COUNT(*) FROM whitelist WHERE symbol = ? AND enabled = TRUE`

	var count int
	err := r.db.QueryRowContext(ctx, query, symbol).Scan(&count)
	if err != nil {
		return false, fmt.Errorf("failed to check whitelist: %w", err)
	}

	return count > 0, nil
}