Enha: settings with room

crons/main.go

@@ -65,6 +65,9 @@ func (cm *CronManager) CleanupRooms() {
 			if err := cm.repo.RoomDeleteByID(ctx, room.ID); err != nil {
 				cm.log.Error("failed to delete empty room", "room_id", room.ID, "err", err)
 			}
+			if err := cm.repo.SettingsDeleteByRoomID(ctx, room.ID); err != nil {
+				cm.log.Error("failed to delete settings for empty room", "room_id", room.ID, "err", err)
+			}
 			continue
 		}
 
@@ -92,6 +95,9 @@ func (cm *CronManager) CleanupRooms() {
 			if err := cm.repo.RoomDeleteByID(ctx, room.ID); err != nil {
 				cm.log.Error("failed to delete room after creator left", "room_id", room.ID, "err", err)
 			}
+			if err := cm.repo.SettingsDeleteByRoomID(ctx, room.ID); err != nil {
+				cm.log.Error("failed to delete settings after creator left", "room_id", room.ID, "err", err)
+			}
 		}
 	}
 

handlers/game.go

@@ -200,7 +200,7 @@ func HandleStartGame(w http.ResponseWriter, r *http.Request) {
 	// Save action history
 	action.RoomID = fi.Room.ID
 	action.CreatedAt = time.Now()
-	if err := repo.CreateAction(ctx, fi.Room.ID, &action); err != nil {
+	if err := repo.CreateAction(ctx, &action); err != nil {
 		if err := tx.Rollback(); err != nil {
 			log.Error("failed to rollback transaction", "error", err)
 		}

handlers/timer.go

@@ -28,19 +28,25 @@ func StartTurnTimer(roomID string, duration time.Duration) {
 	done := make(chan bool)
 	timers[roomID] = &roomTimer{ticker: ticker, done: done}
 	go func() {
+		settings, err := repo.SettingsGetByRoomID(context.Background(), roomID)
+		if err != nil {
+			log.Error("failed to get settings by room id", "error", err)
+			StopTurnTimer(roomID)
+			return
+		}
 		for {
 			select {
 			case <-done:
 				return
 			case <-ticker.C:
+				if settings.TurnSecondsLeft <= 0 {
+					log.Info("turn time is over", "room_id", roomID)
 					room, err := repo.RoomGetByID(context.Background(), roomID)
 					if err != nil {
 						log.Error("failed to get room by id", "error", err)
 						StopTurnTimer(roomID)
 						return
 					}
-				if room.Settings.TurnSecondsLeft <= 0 {
-					log.Info("turn time is over", "room_id", roomID)
 					room.ChangeTurn()
 					room.MimeDone = false
 					if err := repo.RoomUpdate(context.Background(), room); err != nil {
@@ -51,11 +57,11 @@ func StartTurnTimer(roomID string, duration time.Duration) {
 					StopTurnTimer(roomID)
 					return
 				}
-				room.Settings.TurnSecondsLeft--
+				settings.TurnSecondsLeft--
-				// if err := saveRoom(room); err != nil {
+				if err := repo.SettingsUpdate(context.Background(), settings); err != nil {
-				// 	log.Error("failed to save room", "error", err)
+					log.Error("failed to update settings", "error", err)
-				// }
+				}
-				notify(models.NotifyRoomUpdatePrefix+room.ID, "")
+				notify(models.NotifyRoomUpdatePrefix+roomID, "")
 			}
 		}
 	}()

migrations/001_initial_schema.up.sql

@@ -65,6 +65,7 @@ CREATE TABLE settings (
     language TEXT NOT NULL DEFAULT 'en',
     room_pass TEXT NOT NULL DEFAULT '',
     turn_time INTEGER NOT NULL DEFAULT 60, -- seconds
+    turn_seconds_left INTEGER NOT NULL DEFAULT 0,
     created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     FOREIGN KEY (room_id) REFERENCES rooms(id) ON DELETE CASCADE
 );

models/main.go

@@ -390,7 +390,7 @@ type GameSettings struct {
 	RoomID          string    `db:"room_id"`
 	Language        string    `json:"language" example:"en" form:"language" db:"language"`
 	RoomPass        string    `json:"room_pass" db:"room_pass"`
-	TurnSecondsLeft uint32    `db:"-"`
+	TurnSecondsLeft uint32    `db:"turn_seconds_left"`
 	RoundTime       uint32    `json:"round_time" db:"turn_time"`
 	CreatedAt       time.Time `db:"created_at"`
 }

repos/actions_test.go

@@ -50,9 +50,10 @@ func TestActionsRepo_CreateAction(t *testing.T) {
 		WordColor:  "red",
 		Number:     "3",
 		CreatedAt:  time.Now(),
+		RoomID:     roomID,
 	}
 
-	err := repo.CreateAction(context.Background(), roomID, action)
+	err := repo.CreateAction(context.Background(), action)
 	assert.NoError(t, err)
 
 	var retrievedAction models.Action
@@ -75,6 +76,7 @@ func TestActionsRepo_ListActions(t *testing.T) {
 		Word:       "apple",
 		WordColor:  "red",
 		Number:     "3",
+		RoomID:     roomID,
 		CreatedAt:  time.Now().Add(-2 * time.Second),
 	}
 	action2 := &models.Action{
@@ -84,6 +86,7 @@ func TestActionsRepo_ListActions(t *testing.T) {
 		Word:       "banana",
 		WordColor:  "blue",
 		Number:     "0",
+		RoomID:     roomID,
 		CreatedAt:  time.Now().Add(-1 * time.Second),
 	}
 

repos/main.go

@@ -17,6 +17,7 @@ type AllRepos interface {
 	PlayersRepo
 	SessionsRepo
 	WordCardsRepo
+	SettingsRepo
 	InitTx(ctx context.Context) (context.Context, *sqlx.Tx, error)
 }
 
@@ -32,6 +33,11 @@ func NewRepoProvider(pathToDB string) *RepoProvider {
 		slog.Error("Unable to connect to database", "error", err)
 		os.Exit(1)
 	}
+	_, err = db.Exec("PRAGMA foreign_keys = ON;")
+	if err != nil {
+		slog.Error("Unable to enable foreign keys", "error", err)
+		os.Exit(1)
+	}
 	slog.Info("Successfully connected to database")
 	rp := &RepoProvider{
 		DB:       db,

repos/rooms.go

@@ -47,7 +47,7 @@ func (p *RepoProvider) RoomCreate(ctx context.Context, r *models.Room) error {
 	if err != nil {
 		return err
 	}
-	_, err = db.ExecContext(ctx, `INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, r.ID, r.Settings.Language, r.Settings.RoomPass, r.Settings.RoundTime)
+	_, err = db.ExecContext(ctx, `INSERT INTO settings (room_id, language, room_pass, turn_time, turn_seconds_left) VALUES (?, ?, ?, ?, ?)`, r.ID, r.Settings.Language, r.Settings.RoomPass, r.Settings.RoundTime, r.Settings.TurnSecondsLeft)
 	return err
 }
 
@@ -63,7 +63,7 @@ func (p *RepoProvider) RoomUpdate(ctx context.Context, r *models.Room) error {
 	if err != nil {
 		return err
 	}
-	_, err = db.ExecContext(ctx, `UPDATE settings SET language = ?, room_pass = ?, turn_time = ? WHERE room_id = ?`, r.Settings.Language, r.Settings.RoomPass, r.Settings.RoundTime, r.ID)
+	_, err = db.ExecContext(ctx, `UPDATE settings SET language = ?, room_pass = ?, turn_time = ?, turn_seconds_left = ? WHERE room_id = ?`, r.Settings.Language, r.Settings.RoomPass, r.Settings.RoundTime, r.Settings.TurnSecondsLeft, r.ID)
 	return err
 }
 

repos/rooms_test.go

@@ -84,6 +84,7 @@ func setupTestDB(t *testing.T) (*sqlx.DB, func()) {
 		language TEXT NOT NULL DEFAULT 'en',
 		room_pass TEXT NOT NULL DEFAULT '',
 		turn_time INTEGER NOT NULL DEFAULT 60,
+		turn_seconds_left INTEGER NOT NULL DEFAULT 0,
 		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
 		FOREIGN KEY (room_id) REFERENCES rooms(id) ON DELETE CASCADE
 	);
@@ -144,11 +145,12 @@ func TestRoomsRepo_CreateRoom(t *testing.T) {
 	assert.Equal(t, room.CreatorName, retrievedRoom.CreatorName)
 
 	var retrievedSettings models.GameSettings
-	err = db.Get(&retrievedSettings, "SELECT id, language, room_pass, turn_time FROM settings WHERE room_id = ?", room.ID)
+	err = db.Get(&retrievedSettings, "SELECT id, language, room_pass, turn_time, turn_seconds_left FROM settings WHERE room_id = ?", room.ID)
 	assert.NoError(t, err)
 	assert.Equal(t, room.Settings.Language, retrievedSettings.Language)
 	assert.Equal(t, room.Settings.RoundTime, retrievedSettings.RoundTime)
 	assert.Equal(t, room.Settings.RoomPass, retrievedSettings.RoomPass)
+	assert.Equal(t, room.Settings.TurnSecondsLeft, retrievedSettings.TurnSecondsLeft)
 }
 
 func TestRoomsRepo_GetRoomByID(t *testing.T) {
@@ -182,7 +184,7 @@ func TestRoomsRepo_GetRoomByID(t *testing.T) {
 	// Insert a room directly into the database for testing GetRoomByID
 	_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsRunning, room.IsOver, room.TeamWon, room.RoomLink)
 	assert.NoError(t, err)
-	_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, room.ID, room.Settings.Language, room.Settings.RoomPass, room.Settings.RoundTime)
+		_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time, turn_seconds_left) VALUES (?, ?, ?, ?, ?)`, room.ID, room.Settings.Language, room.Settings.RoomPass, room.Settings.RoundTime, room.Settings.TurnSecondsLeft)
 	assert.NoError(t, err)
 
 	retrievedRoom, err := repo.RoomGetByID(context.Background(), room.ID)
@@ -244,12 +246,12 @@ func TestRoomsRepo_ListRooms(t *testing.T) {
 
 	_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room1.ID, room1.CreatedAt, room1.CreatorName, room1.TeamTurn, room1.ThisTurnLimit, room1.OpenedThisTurn, room1.BlueCounter, room1.RedCounter, room1.RedTurn, room1.MimeDone, room1.IsRunning, room1.IsOver, room1.TeamWon, room1.RoomLink)
 	assert.NoError(t, err)
-	_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, room1.ID, room1.Settings.Language, room1.Settings.RoomPass, room1.Settings.RoundTime)
+	_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time, turn_seconds_left) VALUES (?, ?, ?, ?, ?)`, room1.ID, room1.Settings.Language, room1.Settings.RoomPass, room1.Settings.RoundTime, room1.Settings.TurnSecondsLeft)
 	assert.NoError(t, err)
 
 	_, err = db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room2.ID, room2.CreatedAt, room2.CreatorName, room2.TeamTurn, room2.ThisTurnLimit, room2.OpenedThisTurn, room2.BlueCounter, room2.RedCounter, room2.RedTurn, room2.MimeDone, room2.IsRunning, room2.IsOver, room2.TeamWon, room2.RoomLink)
 	assert.NoError(t, err)
-	_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, room2.ID, room2.Settings.Language, room2.Settings.RoomPass, room2.Settings.RoundTime)
+	_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time, turn_seconds_left) VALUES (?, ?, ?, ?, ?)`, room2.ID, room2.Settings.Language, room2.Settings.RoomPass, room2.Settings.RoundTime, room2.Settings.TurnSecondsLeft)
 	assert.NoError(t, err)
 
 	rooms, err := repo.RoomList(context.Background())
@@ -287,7 +289,7 @@ func TestRoomsRepo_DeleteRoomByID(t *testing.T) {
 
 	_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsRunning, room.IsOver, room.TeamWon, room.RoomLink)
 	assert.NoError(t, err)
-	_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, room.ID, room.Settings.Language, room.Settings.RoomPass, room.Settings.RoundTime)
+		_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time, turn_seconds_left) VALUES (?, ?, ?, ?, ?)`, room.ID, room.Settings.Language, room.Settings.RoomPass, room.Settings.RoundTime, room.Settings.TurnSecondsLeft)
 	assert.NoError(t, err)
 
 	// Insert a word card for the room
@@ -348,16 +350,19 @@ func TestRoomsRepo_UpdateRoom(t *testing.T) {
 
 	_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsRunning, room.IsOver, room.TeamWon, room.RoomLink)
 	assert.NoError(t, err)
-	_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, room.ID, room.Settings.Language, room.Settings.RoomPass, room.Settings.RoundTime)
+		_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time, turn_seconds_left) VALUES (?, ?, ?, ?, ?)`, room.ID, room.Settings.Language, room.Settings.RoomPass, room.Settings.RoundTime, room.Settings.TurnSecondsLeft)
 	assert.NoError(t, err)
 
 	room.TeamTurn = "red"
 	room.BlueCounter = 10
 	room.Settings.RoundTime = 120
+	room.Settings.TurnSecondsLeft = 30 // Set a value for turn_seconds_left
 
 	err = repo.RoomUpdate(context.Background(), room)
 	assert.NoError(t, err)
 
+	
+
 	var updatedRoom models.Room
 	err = db.Get(&updatedRoom, "SELECT * FROM rooms WHERE id = ?", room.ID)
 	assert.NoError(t, err)
@@ -368,4 +373,5 @@ func TestRoomsRepo_UpdateRoom(t *testing.T) {
 	err = db.Get(&updatedSettings, "SELECT * FROM settings WHERE room_id = ?", room.ID)
 	assert.NoError(t, err)
 	assert.Equal(t, uint32(120), updatedSettings.RoundTime)
+	assert.Equal(t, uint32(30), updatedSettings.TurnSecondsLeft)
 }

repos/settings.go

@@ -0,0 +1,35 @@
+package repos
+
+import (
+	"context"
+	"gralias/models"
+
+	"github.com/jmoiron/sqlx"
+)
+
+type SettingsRepo interface {
+	SettingsGetByRoomID(ctx context.Context, roomID string) (*models.GameSettings, error)
+	SettingsUpdate(ctx context.Context, settings *models.GameSettings) error
+	SettingsDeleteByRoomID(ctx context.Context, roomID string) error
+}
+
+func (p *RepoProvider) SettingsGetByRoomID(ctx context.Context, roomID string) (*models.GameSettings, error) {
+	settings := &models.GameSettings{}
+	err := sqlx.GetContext(ctx, p.DB, settings, `SELECT * FROM settings WHERE room_id = ?`, roomID)
+	if err != nil {
+		return nil, err
+	}
+	return settings, nil
+}
+
+func (p *RepoProvider) SettingsUpdate(ctx context.Context, s *models.GameSettings) error {
+	db := getDB(ctx, p.DB)
+	_, err := db.ExecContext(ctx, `UPDATE settings SET language = ?, room_pass = ?, turn_time = ?, turn_seconds_left = ? WHERE room_id = ?`, s.Language, s.RoomPass, s.RoundTime, s.TurnSecondsLeft, s.RoomID)
+	return err
+}
+
+func (p *RepoProvider) SettingsDeleteByRoomID(ctx context.Context, roomID string) error {
+	db := getDB(ctx, p.DB)
+	_, err := db.ExecContext(ctx, `DELETE FROM settings WHERE room_id = ?`, roomID)
+	return err
+}

repos/settings_test.go

@@ -0,0 +1,57 @@
+package repos
+
+import (
+	"context"
+	"gralias/models"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func TestSettingsRepo_SettingsUpdate(t *testing.T) {
+	db, teardown := setupTestDB(t)
+	defer teardown()
+
+	repo := &RepoProvider{DB: db}
+
+	// Create a dummy room first
+	room := &models.Room{
+		ID:          "test_room_settings",
+		CreatedAt:   time.Now(),
+		CreatorName: "test_creator",
+	}
+	_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name) VALUES (?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName)
+	assert.NoError(t, err)
+
+	settings := &models.GameSettings{
+		RoomID:          "test_room_settings",
+		Language:        "en",
+		RoomPass:        "pass123",
+		RoundTime:       60,
+		TurnSecondsLeft: 60,
+		CreatedAt:       time.Now(),
+	}
+
+	// Insert initial settings
+	_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time, turn_seconds_left, created_at) VALUES (?, ?, ?, ?, ?, ?)`, settings.RoomID, settings.Language, settings.RoomPass, settings.RoundTime, settings.TurnSecondsLeft, settings.CreatedAt)
+	assert.NoError(t, err)
+
+	// Update settings
+	settings.RoundTime = 120
+	settings.TurnSecondsLeft = 30
+	settings.Language = "ru"
+
+	err = repo.SettingsUpdate(context.Background(), settings)
+	assert.NoError(t, err)
+
+	// Verify updated settings
+	var updatedSettings models.GameSettings
+	err = db.Get(&updatedSettings, "SELECT * FROM settings WHERE room_id = ?", settings.RoomID)
+	assert.NoError(t, err)
+
+	assert.Equal(t, uint32(120), updatedSettings.RoundTime)
+	assert.Equal(t, uint32(30), updatedSettings.TurnSecondsLeft)
+	assert.Equal(t, "ru", updatedSettings.Language)
+}