grail/gralias
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: grail:058d501774d141813c10ecc7cb8c4d98eb29cb4b
Branches Tags
grail:master
...
compare: grail:705881f1eac99a46629aaa1f25f849d559dd2d96
Branches Tags
grail:master

2 Commits
058d501774 ... 705881f1ea

Author SHA1 Message Date
Grail Finder
705881f1ea Enha: settings with room 2025-07-04 14:20:25 +03:00
Grail Finder
6be365473c Feat: settings repo 2025-07-04 13:32:59 +03:00
11 changed files with 144 additions and 24 deletions
Expand all files Collapse all files

6
crons/main.go
View File

@ -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)
}
}
}

2
handlers/game.go
View File

@ -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)
}

30
handlers/timer.go
View File

@ -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:
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 {
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
}
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--
// if err := saveRoom(room); err != nil {
// log.Error("failed to save room", "error", err)
// }
notify(models.NotifyRoomUpdatePrefix+room.ID, "")
settings.TurnSecondsLeft--
if err := repo.SettingsUpdate(context.Background(), settings); err != nil {
log.Error("failed to update settings", "error", err)
}
notify(models.NotifyRoomUpdatePrefix+roomID, "")
}
}
}()

1
migrations/001_initial_schema.up.sql
View File

@ -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
);

2
models/main.go
View File

@ -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"`
}

5
repos/actions_test.go
View File

@ -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),
}

6
repos/main.go
View File

@ -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,

4
repos/rooms.go
View File

@ -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
}

20
repos/rooms_test.go
View File

@ -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)
}

35
repos/settings.go Normal file
View File

@ -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
}

57
repos/settings_test.go Normal file
View File

@ -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)
}