You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
562 lines
15 KiB
562 lines
15 KiB
package db
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"os"
|
|
"path/filepath"
|
|
"track-gopher/models"
|
|
|
|
_ "github.com/mattn/go-sqlite3"
|
|
)
|
|
|
|
// ErrNotFound is returned when a requested record is not found
|
|
var ErrNotFound = errors.New("record not found")
|
|
|
|
// DB represents the database connection
|
|
type DB struct {
|
|
*sql.DB
|
|
logger *slog.Logger
|
|
}
|
|
|
|
// NewDB creates a new database connection
|
|
func New(dbPath string) (*DB, error) {
|
|
logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
|
|
Level: slog.LevelDebug,
|
|
}))
|
|
|
|
// Ensure directory exists
|
|
if err := os.MkdirAll(filepath.Dir(dbPath), 0755); err != nil {
|
|
return nil, fmt.Errorf("failed to create database directory: %w", err)
|
|
}
|
|
|
|
// Open database connection
|
|
sqlDB, err := sql.Open("sqlite3", dbPath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to open database: %w", err)
|
|
}
|
|
|
|
// Create database instance
|
|
db := &DB{
|
|
DB: sqlDB,
|
|
logger: logger,
|
|
}
|
|
|
|
// Initialize schema
|
|
if err := db.initSchema(); err != nil {
|
|
db.Close()
|
|
return nil, fmt.Errorf("failed to initialize schema: %w", err)
|
|
}
|
|
|
|
return db, nil
|
|
}
|
|
|
|
// initSchema creates the database tables if they don't exist
|
|
func (db *DB) initSchema() error {
|
|
// Create groups table
|
|
_, err := db.Exec(`
|
|
CREATE TABLE IF NOT EXISTS groups (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
name TEXT NOT NULL UNIQUE,
|
|
description TEXT,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
)
|
|
`)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create groups table: %w", err)
|
|
}
|
|
|
|
// Create racers table
|
|
_, err = db.Exec(`
|
|
CREATE TABLE IF NOT EXISTS racers (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
first_name TEXT NOT NULL,
|
|
last_name TEXT NOT NULL,
|
|
car_number TEXT NOT NULL UNIQUE,
|
|
car_weight REAL NOT NULL,
|
|
group_id INTEGER NOT NULL,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
FOREIGN KEY (group_id) REFERENCES groups(id)
|
|
)
|
|
`)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create racers table: %w", err)
|
|
}
|
|
|
|
// Create races table
|
|
_, err = db.Exec(`
|
|
CREATE TABLE IF NOT EXISTS races (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
name TEXT NOT NULL,
|
|
status TEXT NOT NULL DEFAULT 'pending',
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
)
|
|
`)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create races table: %w", err)
|
|
}
|
|
|
|
// Create race_results table
|
|
_, err = db.Exec(`
|
|
CREATE TABLE IF NOT EXISTS race_results (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
race_id INTEGER NOT NULL,
|
|
racer_id INTEGER NOT NULL,
|
|
lane INTEGER NOT NULL,
|
|
time REAL,
|
|
place INTEGER,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
FOREIGN KEY (race_id) REFERENCES races(id),
|
|
FOREIGN KEY (racer_id) REFERENCES racers(id),
|
|
UNIQUE(race_id, lane)
|
|
)
|
|
`)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create race_results table: %w", err)
|
|
}
|
|
|
|
// Create heats table
|
|
_, err = db.Exec(`
|
|
CREATE TABLE IF NOT EXISTS heats (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
group_id INTEGER NOT NULL,
|
|
heat_num INTEGER NOT NULL,
|
|
lane1_id INTEGER,
|
|
lane2_id INTEGER,
|
|
lane3_id INTEGER,
|
|
lane4_id INTEGER,
|
|
FOREIGN KEY (group_id) REFERENCES groups(id) ON DELETE CASCADE,
|
|
FOREIGN KEY (lane1_id) REFERENCES racers(id) ON DELETE SET NULL,
|
|
FOREIGN KEY (lane2_id) REFERENCES racers(id) ON DELETE SET NULL,
|
|
FOREIGN KEY (lane3_id) REFERENCES racers(id) ON DELETE SET NULL,
|
|
FOREIGN KEY (lane4_id) REFERENCES racers(id) ON DELETE SET NULL
|
|
)
|
|
`)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create heats table: %w", err)
|
|
}
|
|
|
|
// Create settings table
|
|
_, err = db.Exec(`
|
|
CREATE TABLE IF NOT EXISTS settings (
|
|
key TEXT PRIMARY KEY,
|
|
value TEXT NOT NULL
|
|
);
|
|
`)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create settings table: %w", err)
|
|
}
|
|
|
|
// Create heat_results table
|
|
_, err = db.Exec(`
|
|
CREATE TABLE IF NOT EXISTS heat_results (
|
|
group_id INTEGER NOT NULL,
|
|
heat_number INTEGER NOT NULL,
|
|
lane1_time REAL NOT NULL,
|
|
lane1_position INTEGER NOT NULL,
|
|
lane2_time REAL NOT NULL,
|
|
lane2_position INTEGER NOT NULL,
|
|
lane3_time REAL NOT NULL,
|
|
lane3_position INTEGER NOT NULL,
|
|
lane4_time REAL NOT NULL,
|
|
lane4_position INTEGER NOT NULL,
|
|
PRIMARY KEY (group_id, heat_number),
|
|
FOREIGN KEY (group_id) REFERENCES groups (id) ON DELETE CASCADE
|
|
);
|
|
`)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create heat_results table: %w", err)
|
|
}
|
|
|
|
// Add default settings if they don't exist
|
|
_, err = db.Exec(`
|
|
INSERT OR IGNORE INTO settings (key, value) VALUES ('current_racing_group', '1');
|
|
`)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to add default settings: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Close closes the database connection
|
|
func (db *DB) Close() error {
|
|
return db.DB.Close()
|
|
}
|
|
|
|
// SaveHeats saves the heats for a group, replacing any existing heats
|
|
func (db *DB) SaveHeats(groupID int64, heats []models.Heat) error {
|
|
// Start a transaction
|
|
tx, err := db.Begin()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to begin transaction: %w", err)
|
|
}
|
|
defer tx.Rollback()
|
|
|
|
// Delete existing heats for this group
|
|
_, err = tx.Exec("DELETE FROM heats WHERE group_id = ?", groupID)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete existing heats: %w", err)
|
|
}
|
|
|
|
// Insert new heats
|
|
stmt, err := tx.Prepare("INSERT INTO heats (group_id, heat_num, lane1_id, lane2_id, lane3_id, lane4_id) VALUES (?, ?, ?, ?, ?, ?)")
|
|
if err != nil {
|
|
return fmt.Errorf("failed to prepare statement: %w", err)
|
|
}
|
|
defer stmt.Close()
|
|
|
|
for i, heat := range heats {
|
|
_, err = stmt.Exec(groupID, i+1, heat.Lane1ID, heat.Lane2ID, heat.Lane3ID, heat.Lane4ID)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to insert heat: %w", err)
|
|
}
|
|
}
|
|
|
|
// Commit transaction
|
|
if err := tx.Commit(); err != nil {
|
|
return fmt.Errorf("failed to commit transaction: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetHeats retrieves the saved heats for a group
|
|
func (db *DB) GetHeats(groupID int64) ([]models.Heat, error) {
|
|
rows, err := db.Query(`
|
|
SELECT heat_num, lane1_id, lane2_id, lane3_id, lane4_id
|
|
FROM heats
|
|
WHERE group_id = ?
|
|
ORDER BY heat_num
|
|
`, groupID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to query heats: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var heats []models.Heat
|
|
for rows.Next() {
|
|
var heat models.Heat
|
|
err := rows.Scan(&heat.HeatNum, &heat.Lane1ID, &heat.Lane2ID, &heat.Lane3ID, &heat.Lane4ID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to scan heat: %w", err)
|
|
}
|
|
heats = append(heats, heat)
|
|
}
|
|
|
|
return heats, nil
|
|
}
|
|
|
|
// HasSavedHeats checks if a group has saved heats
|
|
func (db *DB) HasSavedHeats(groupID int64) (bool, error) {
|
|
var count int
|
|
err := db.QueryRow("SELECT COUNT(*) FROM heats WHERE group_id = ?", groupID).Scan(&count)
|
|
if err != nil {
|
|
return false, fmt.Errorf("failed to check for saved heats: %w", err)
|
|
}
|
|
return count > 0, nil
|
|
}
|
|
|
|
// DeleteHeats deletes all heats for a group
|
|
func (db *DB) DeleteHeats(groupID int64) error {
|
|
_, err := db.Exec("DELETE FROM heats WHERE group_id = ?", groupID)
|
|
return err
|
|
}
|
|
|
|
// GetCurrentRacingGroup gets the currently racing group
|
|
func (db *DB) GetCurrentRacingGroup() (models.Group, error) {
|
|
var group models.Group
|
|
|
|
// Get the current racing group ID from settings
|
|
var groupID int64
|
|
err := db.QueryRow("SELECT value FROM settings WHERE key = 'current_racing_group'").Scan(&groupID)
|
|
if err != nil {
|
|
if err == sql.ErrNoRows {
|
|
// If no group is set, get the first group
|
|
err = db.QueryRow("SELECT id, name, description FROM groups ORDER BY id LIMIT 1").Scan(
|
|
&group.ID, &group.Name, &group.Description)
|
|
if err != nil {
|
|
return group, err
|
|
}
|
|
|
|
// Set this as the current racing group
|
|
_, err = db.Exec("INSERT OR REPLACE INTO settings (key, value) VALUES ('current_racing_group', ?)", group.ID)
|
|
return group, err
|
|
}
|
|
return group, err
|
|
}
|
|
|
|
// Get the group details
|
|
err = db.QueryRow("SELECT id, name, description FROM groups WHERE id = ?", groupID).Scan(
|
|
&group.ID, &group.Name, &group.Description)
|
|
return group, err
|
|
}
|
|
|
|
// SetCurrentRacingGroup sets the currently racing group
|
|
func (db *DB) SetCurrentRacingGroup(groupID int64) error {
|
|
_, err := db.Exec("INSERT OR REPLACE INTO settings (key, value) VALUES ('current_racing_group', ?)", groupID)
|
|
return err
|
|
}
|
|
|
|
// GetCurrentHeatNumber gets the current heat number for a group
|
|
func (db *DB) GetCurrentHeatNumber(groupID int64) (int, error) {
|
|
var heatNum int
|
|
key := fmt.Sprintf("current_heat_%d", groupID)
|
|
|
|
err := db.QueryRow("SELECT value FROM settings WHERE key = ?", key).Scan(&heatNum)
|
|
if err != nil {
|
|
if err == sql.ErrNoRows {
|
|
// If no heat is set, default to 1
|
|
_, err = db.Exec("INSERT INTO settings (key, value) VALUES (?, 1)", key)
|
|
return 1, err
|
|
}
|
|
return 0, err
|
|
}
|
|
|
|
return heatNum, nil
|
|
}
|
|
|
|
// SetCurrentHeatNumber sets the current heat number for a group
|
|
func (db *DB) SetCurrentHeatNumber(groupID int64, heatNum int) error {
|
|
key := fmt.Sprintf("current_heat_%d", groupID)
|
|
_, err := db.Exec("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)", key, heatNum)
|
|
return err
|
|
}
|
|
|
|
// SaveHeatResult saves the result of a heat
|
|
func (db *DB) SaveHeatResult(result models.HeatResult) error {
|
|
db.logger.Info("Saving heat result", "result", result)
|
|
// Check if result already exists
|
|
var count int
|
|
err := db.QueryRow("SELECT COUNT(*) FROM heat_results WHERE group_id = ? AND heat_number = ?",
|
|
result.GroupID, result.HeatNumber).Scan(&count)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if count > 0 {
|
|
// Update existing result
|
|
_, err = db.Exec(`
|
|
UPDATE heat_results SET
|
|
lane1_time = ?, lane1_position = ?,
|
|
lane2_time = ?, lane2_position = ?,
|
|
lane3_time = ?, lane3_position = ?,
|
|
lane4_time = ?, lane4_position = ?
|
|
WHERE group_id = ? AND heat_number = ?`,
|
|
result.Lane1Time, result.Lane1Position,
|
|
result.Lane2Time, result.Lane2Position,
|
|
result.Lane3Time, result.Lane3Position,
|
|
result.Lane4Time, result.Lane4Position,
|
|
result.GroupID, result.HeatNumber)
|
|
} else {
|
|
// Insert new result
|
|
_, err = db.Exec(`
|
|
INSERT INTO heat_results (
|
|
group_id, heat_number,
|
|
lane1_time, lane1_position,
|
|
lane2_time, lane2_position,
|
|
lane3_time, lane3_position,
|
|
lane4_time, lane4_position
|
|
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
result.GroupID, result.HeatNumber,
|
|
result.Lane1Time, result.Lane1Position,
|
|
result.Lane2Time, result.Lane2Position,
|
|
result.Lane3Time, result.Lane3Position,
|
|
result.Lane4Time, result.Lane4Position)
|
|
}
|
|
|
|
db.logger.Info("Saved heat result", "result", result)
|
|
return err
|
|
}
|
|
|
|
// GetHeatResult gets the result of a specific heat
|
|
func (db *DB) GetHeatResult(groupID int64, heatNum int) (*models.HeatResult, error) {
|
|
result := &models.HeatResult{}
|
|
|
|
err := db.QueryRow(`
|
|
SELECT
|
|
group_id, heat_number,
|
|
lane1_time, lane1_position,
|
|
lane2_time, lane2_position,
|
|
lane3_time, lane3_position,
|
|
lane4_time, lane4_position
|
|
FROM heat_results
|
|
WHERE group_id = ? AND heat_number = ?`,
|
|
groupID, heatNum).Scan(
|
|
&result.GroupID, &result.HeatNumber,
|
|
&result.Lane1Time, &result.Lane1Position,
|
|
&result.Lane2Time, &result.Lane2Position,
|
|
&result.Lane3Time, &result.Lane3Position,
|
|
&result.Lane4Time, &result.Lane4Position)
|
|
|
|
if err != nil {
|
|
if err == sql.ErrNoRows {
|
|
return nil, ErrNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// GetHeatResults gets all heat results for a group
|
|
func (db *DB) GetHeatResults(groupID int64) ([]models.HeatResult, error) {
|
|
db.logger.Info("Getting heat results for group", "groupID", groupID)
|
|
rows, err := db.Query(`
|
|
SELECT
|
|
group_id, heat_number,
|
|
lane1_time, lane1_position,
|
|
lane2_time, lane2_position,
|
|
lane3_time, lane3_position,
|
|
lane4_time, lane4_position
|
|
FROM heat_results
|
|
WHERE group_id = ?
|
|
ORDER BY heat_number`,
|
|
groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var results []models.HeatResult
|
|
for rows.Next() {
|
|
var result models.HeatResult
|
|
err := rows.Scan(
|
|
&result.GroupID, &result.HeatNumber,
|
|
&result.Lane1Time, &result.Lane1Position,
|
|
&result.Lane2Time, &result.Lane2Position,
|
|
&result.Lane3Time, &result.Lane3Position,
|
|
&result.Lane4Time, &result.Lane4Position)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
results = append(results, result)
|
|
}
|
|
|
|
db.logger.Info("Heat results", "results", results)
|
|
return results, nil
|
|
}
|
|
|
|
// DeleteHeatResult deletes a heat result
|
|
func (db *DB) DeleteHeatResult(groupID int64, heatNum int) error {
|
|
_, err := db.Exec("DELETE FROM heat_results WHERE group_id = ? AND heat_number = ?",
|
|
groupID, heatNum)
|
|
return err
|
|
}
|
|
|
|
func (db *DB) GetHeatData(groupID int64, heatNum int) (*models.HeatData, error) {
|
|
db.logger.Info("Getting heat data for group", "groupID", groupID, "heatNum", heatNum)
|
|
heatData := &models.HeatData{}
|
|
lane1 := int64(0)
|
|
lane2 := int64(0)
|
|
lane3 := int64(0)
|
|
lane4 := int64(0)
|
|
|
|
err := db.QueryRow(`
|
|
SELECT
|
|
group_id, heat_num,
|
|
g.name as group_name,
|
|
(SELECT COUNT(*) FROM heats WHERE group_id = ?) as total_heats,
|
|
h.lane1_id, h.lane2_id, h.lane3_id, h.lane4_id
|
|
FROM heats h
|
|
JOIN groups g ON g.id = h.group_id
|
|
WHERE h.group_id = ? AND h.heat_num = ?`,
|
|
groupID, groupID, heatNum).Scan(
|
|
&heatData.Group.ID, &heatData.HeatNumber,
|
|
&heatData.Group.Name, &heatData.TotalHeats,
|
|
&lane1, &lane2, &lane3, &lane4)
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error getting heat data: %v", err)
|
|
}
|
|
|
|
// Get racer data for each lane
|
|
if lane1 != 0 {
|
|
lane1Data, err := db.getLaneData(1, lane1, heatNum, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
heatData.Lane1 = lane1Data
|
|
}
|
|
|
|
if lane2 != 0 {
|
|
lane2Data, err := db.getLaneData(2, lane2, heatNum, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
heatData.Lane2 = lane2Data
|
|
}
|
|
|
|
if lane3 != 0 {
|
|
lane3Data, err := db.getLaneData(3, lane3, heatNum, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
heatData.Lane3 = lane3Data
|
|
}
|
|
|
|
if lane4 != 0 {
|
|
lane4Data, err := db.getLaneData(4, lane4, heatNum, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
heatData.Lane4 = lane4Data
|
|
}
|
|
|
|
db.logger.Info("Heat data", "heatData", heatData)
|
|
return heatData, nil
|
|
}
|
|
|
|
// getLaneData gets the racer data for a specific lane
|
|
func (db *DB) getLaneData(lane int, racerID int64, heatNum int, groupID int64) (*models.LaneData, error) {
|
|
// Get racer data
|
|
var racer models.Racer
|
|
err := db.QueryRow(`
|
|
SELECT id, first_name, last_name, car_number, car_weight, group_id
|
|
FROM racers
|
|
WHERE id = ?`, racerID).Scan(
|
|
&racer.ID, &racer.FirstName, &racer.LastName, &racer.CarNumber, &racer.CarWeight, &racer.GroupID)
|
|
|
|
if err != nil {
|
|
if err == sql.ErrNoRows {
|
|
return nil, ErrNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// Create lane data with racer info
|
|
laneData := &models.LaneData{
|
|
Lane: lane,
|
|
RacerID: racerID,
|
|
Name: racer.FirstName + " " + racer.LastName,
|
|
CarNum: racer.CarNumber,
|
|
CarWeight: racer.CarWeight,
|
|
Time: 0,
|
|
Place: 0,
|
|
}
|
|
|
|
heatResult, err := db.GetHeatResult(groupID, heatNum)
|
|
if err != nil {
|
|
return laneData, nil
|
|
}
|
|
|
|
switch lane {
|
|
case 1:
|
|
laneData.Time = heatResult.Lane1Time
|
|
laneData.Place = heatResult.Lane1Position
|
|
case 2:
|
|
laneData.Time = heatResult.Lane2Time
|
|
laneData.Place = heatResult.Lane2Position
|
|
case 3:
|
|
laneData.Time = heatResult.Lane3Time
|
|
laneData.Place = heatResult.Lane3Position
|
|
case 4:
|
|
laneData.Time = heatResult.Lane4Time
|
|
laneData.Place = heatResult.Lane4Position
|
|
}
|
|
|
|
return laneData, nil
|
|
}
|