connector not configured (set BACKEND_CONNECTOR_ADDR)
{{end}} diff --git a/backend/internal/adminconsole/templates/pages/feedback_detail.gohtml b/backend/internal/adminconsole/templates/pages/feedback_detail.gohtml index 3ba3e4d..6d217b9 100644 --- a/backend/internal/adminconsole/templates/pages/feedback_detail.gohtml +++ b/backend/internal/adminconsole/templates/pages/feedback_detail.gohtml @@ -5,7 +5,7 @@{{.IP}}{{else}}none{{end}}connector not configured (set BACKEND_CONNECTOR_ADDR)
{{end}} diff --git a/backend/internal/adminconsole/views.go b/backend/internal/adminconsole/views.go index 7142021..eb3aafb 100644 --- a/backend/internal/adminconsole/views.go +++ b/backend/internal/adminconsole/views.go @@ -531,11 +531,8 @@ type FeedbackDetailView struct { SenderName string Source string Channel string - // InterfaceLanguage is the sender's interface language (account preference); - // BotLanguage is the connector bot they last used (en/ru), set only for a - // message that arrived through an external connector (Telegram). + // InterfaceLanguage is the sender's interface language (account preference). InterfaceLanguage string - BotLanguage string IP string Body string HasAttachment bool diff --git a/backend/internal/connector/client.go b/backend/internal/connector/client.go index 0030275..5b8196d 100644 --- a/backend/internal/connector/client.go +++ b/backend/internal/connector/client.go @@ -1,11 +1,10 @@ // Package connector is the backend's gRPC client for the Telegram platform // connector side-service. The admin console uses it to send operator broadcasts: -// a direct message to one user, or a post to a game channel. Each broadcast -// selects the delivering bot by language (an operator choice, since the connector -// hosts one bot per service language). The connector lives on the trusted internal -// network, so the connection uses insecure (plaintext) transport credentials -// (docs/ARCHITECTURE.md §12). It mirrors gateway/internal/connector, narrowed to -// the two broadcast methods the admin surface needs. +// a direct message to one user, or a post to the game channel, through the single +// bot. The connector lives on the trusted internal network, so the connection uses +// insecure (plaintext) transport credentials (docs/ARCHITECTURE.md §12). It mirrors +// gateway/internal/connector, narrowed to the two broadcast methods the admin +// surface needs. package connector import ( @@ -37,22 +36,21 @@ func New(addr string) (*Client, error) { func (c *Client) Close() error { return c.conn.Close() } // SendToUser sends an operator text message to one user, addressed by their -// platform external_id, through the bot for the given language. delivered reports -// whether the connector actually sent it (false when the user has not started that -// bot). -func (c *Client) SendToUser(ctx context.Context, externalID, text, language string) (bool, error) { - resp, err := c.c.SendToUser(ctx, &telegramv1.SendToUserRequest{ExternalId: externalID, Text: text, Language: language}) +// platform external_id, through the bot. delivered reports whether the connector +// actually sent it (false when the user has not started the bot). +func (c *Client) SendToUser(ctx context.Context, externalID, text string) (bool, error) { + resp, err := c.c.SendToUser(ctx, &telegramv1.SendToUserRequest{ExternalId: externalID, Text: text}) if err != nil { return false, err } return resp.GetDelivered(), nil } -// SendToGameChannel posts an operator text message to the game channel of the bot -// for the given language. delivered reports whether the connector sent it (false -// when that bot has no channel configured). -func (c *Client) SendToGameChannel(ctx context.Context, text, language string) (bool, error) { - resp, err := c.c.SendToGameChannel(ctx, &telegramv1.SendToGameChannelRequest{Text: text, Language: language}) +// SendToGameChannel posts an operator text message to the bot's game channel. +// delivered reports whether the connector sent it (false when the bot has no +// channel configured). +func (c *Client) SendToGameChannel(ctx context.Context, text string) (bool, error) { + resp, err := c.c.SendToGameChannel(ctx, &telegramv1.SendToGameChannelRequest{Text: text}) if err != nil { return false, err } diff --git a/backend/internal/feedback/service.go b/backend/internal/feedback/service.go index d0b22be..824cff9 100644 --- a/backend/internal/feedback/service.go +++ b/backend/internal/feedback/service.go @@ -112,14 +112,9 @@ func (svc *Service) Submit(ctx context.Context, accountID uuid.UUID, body string attachmentName = "" // a name without bytes carries no attachment } ch := normalizeChannel(channel) - // Snapshot the languages at submit time (acc is already loaded for the guest check): - // the sender's interface language, and the connector bot language when the message - // came through an external connector (currently Telegram). - var channelLang string - if ch == "telegram" { - channelLang = acc.ServiceLanguage - } - _, err = svc.store.Insert(ctx, accountID, body, attachment, attachmentName, ch, acc.PreferredLanguage, channelLang, parseIP(senderIP)) + // Snapshot the sender's interface language at submit time (acc is already loaded + // for the guest check) so the operator later sees the state as it was. + _, err = svc.store.Insert(ctx, accountID, body, attachment, attachmentName, ch, acc.PreferredLanguage, parseIP(senderIP)) return err } diff --git a/backend/internal/feedback/store.go b/backend/internal/feedback/store.go index 2e64e39..5281978 100644 --- a/backend/internal/feedback/store.go +++ b/backend/internal/feedback/store.go @@ -34,11 +34,10 @@ func NewStore(db *sql.DB) *Store { // Insert stores one feedback message from accountID and returns its id. attachment // is the raw file bytes (nil for none); attachmentName, ip and a non-default -// channel are stored as given. lang (the sender's interface language) and channelLang -// (the connector bot language, empty for a non-connector channel) are snapshots taken -// now, so the operator later sees the state at submit time. created_at defaults to -// now() in the database. -func (s *Store) Insert(ctx context.Context, accountID uuid.UUID, body string, attachment []byte, attachmentName, channel, lang, channelLang string, ip *string) (uuid.UUID, error) { +// channel are stored as given. lang (the sender's interface language) is a snapshot +// taken now, so the operator later sees the state at submit time. created_at defaults +// to now() in the database. +func (s *Store) Insert(ctx context.Context, accountID uuid.UUID, body string, attachment []byte, attachmentName, channel, lang string, ip *string) (uuid.UUID, error) { id, err := uuid.NewV7() if err != nil { return uuid.Nil, fmt.Errorf("feedback: new message id: %w", err) @@ -49,9 +48,9 @@ func (s *Store) Insert(ctx context.Context, accountID uuid.UUID, body string, at } if _, err := s.db.ExecContext(ctx, `INSERT INTO backend.feedback_messages - (message_id, account_id, body, attachment, attachment_name, channel, lang, channel_lang, sender_ip) - VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`, - id, accountID, body, att, nullStr(attachmentName), channel, nullStr(lang), nullStr(channelLang), ip); err != nil { + (message_id, account_id, body, attachment, attachment_name, channel, lang, sender_ip) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, + id, accountID, body, att, nullStr(attachmentName), channel, nullStr(lang), ip); err != nil { return uuid.Nil, fmt.Errorf("feedback: insert: %w", err) } return id, nil @@ -228,10 +227,8 @@ type AdminMessage struct { Source string Body string Channel string - // Lang is the sender's interface language and ChannelLang the connector bot language - // (en/ru, empty for a non-connector channel) — both snapshotted at submit time. + // Lang is the sender's interface language, snapshotted at submit time. Lang string - ChannelLang string SenderIP string HasAttachment bool AttachmentName string @@ -346,7 +343,7 @@ func (s *Store) AdminGet(ctx context.Context, id uuid.UUID) (AdminMessage, error var m AdminMessage var repliedAt sql.NullTime q := `SELECT m.message_id, m.account_id, a.display_name, ` + feedbackSource + ` AS source, m.body, m.channel, - COALESCE(m.lang, ''), COALESCE(m.channel_lang, ''), + COALESCE(m.lang, ''), COALESCE(m.sender_ip, ''), (m.attachment IS NOT NULL), COALESCE(m.attachment_name, ''), (m.read_at IS NOT NULL), (m.archived_at IS NOT NULL), (m.reply_body IS NOT NULL), COALESCE(m.reply_body, ''), m.replied_at, m.created_at @@ -355,7 +352,7 @@ func (s *Store) AdminGet(ctx context.Context, id uuid.UUID) (AdminMessage, error WHERE m.message_id = $1` err := s.db.QueryRowContext(ctx, q, id).Scan( &m.ID, &m.AccountID, &m.SenderName, &m.Source, &m.Body, &m.Channel, - &m.Lang, &m.ChannelLang, + &m.Lang, &m.SenderIP, &m.HasAttachment, &m.AttachmentName, &m.Read, &m.Archived, &m.Replied, &m.ReplyBody, &repliedAt, &m.CreatedAt) if errors.Is(err, sql.ErrNoRows) { diff --git a/backend/internal/game/emit_test.go b/backend/internal/game/emit_test.go index db953de..9a05483 100644 --- a/backend/internal/game/emit_test.go +++ b/backend/internal/game/emit_test.go @@ -68,10 +68,6 @@ func TestEmitMoveNotifiesActor(t *testing.T) { if got := string(yt.ScoreLine()); got != "13:19" { // seat 1 (recipient) first, then seat 0 t.Errorf("your_turn score_line = %q, want 13:19", got) } - // Routed out-of-app by the game's language (the default Variant is English). - if yourTurn.Language != "en" { - t.Errorf("your_turn language = %q, want en", yourTurn.Language) - } } // TestEmitMoveAnnouncesGameOver checks the closing move sends a game_over push to every seat, @@ -106,7 +102,4 @@ func TestEmitMoveAnnouncesGameOver(t *testing.T) { if string(l.Result()) != "lost" || string(l.ScoreLine()) != "95:120" { t.Errorf("loser game_over = %q / %q, want lost / 95:120", l.Result(), l.ScoreLine()) } - if over[winner].Language != "en" || over[loser].Language != "en" { - t.Errorf("game_over languages = %q/%q, want en/en", over[winner].Language, over[loser].Language) - } } diff --git a/backend/internal/game/service.go b/backend/internal/game/service.go index 3da994c..1c0dbd0 100644 --- a/backend/internal/game/service.go +++ b/backend/internal/game/service.go @@ -554,16 +554,6 @@ func (svc *Service) GameVariant(ctx context.Context, gameID uuid.UUID) (engine.V return svc.store.GetGameVariant(ctx, gameID) } -// GameLanguage returns the game's language tag ("en"/"ru"), derived from its variant, so a -// game push routes out-of-app to the game's own bot rather than the recipient's last-login bot. -func (svc *Service) GameLanguage(ctx context.Context, gameID uuid.UUID) (string, error) { - v, err := svc.GameVariant(ctx, gameID) - if err != nil { - return "", err - } - return v.Language(), nil -} - // RobotSchedule returns a game's bag seed and turn-start time, for the admin console's // robot-schedule panel (the deterministic play-to-win intent and next-move ETA). func (svc *Service) RobotSchedule(ctx context.Context, gameID uuid.UUID) (seed int64, turnStartedAt time.Time, err error) { @@ -740,9 +730,6 @@ func (svc *Service) emitMove(ctx context.Context, post Game, rec engine.MoveReco } intents = append(intents, notify.OpponentMoved(s.AccountID, post.ID, rec, summary, bagLen)) } - // Game pushes are routed out-of-app by the game's own language, not the recipient's - // last-login bot. - lang := post.Variant.Language() switch post.Status { case StatusActive: // Honest-AI games suppress your_turn: the robot replies instantly, so a "your turn" @@ -757,7 +744,6 @@ func (svc *Service) emitMove(ctx context.Context, post Game, rec engine.MoveReco } opponent := svc.displayName(ctx, post.Seats, rec.Player) yourTurn := notify.YourTurn(next, post.ID, deadline, opponent, action, word, scoreLine(post, post.ToMove), post.MoveCount) - yourTurn.Language = lang intents = append(intents, yourTurn) } case StatusFinished: @@ -769,7 +755,6 @@ func (svc *Service) emitMove(ctx context.Context, post Game, rec engine.MoveReco continue } over := notify.GameOver(s.AccountID, post.ID, seatResult(post.Seats, s.Seat), scoreLine(post, s.Seat), summary) - over.Language = lang intents = append(intents, over) } } diff --git a/backend/internal/inttest/account_test.go b/backend/internal/inttest/account_test.go index c7f1815..b9327a7 100644 --- a/backend/internal/inttest/account_test.go +++ b/backend/internal/inttest/account_test.go @@ -159,46 +159,6 @@ func TestProvisionTelegramUnknownLanguageDefaults(t *testing.T) { } } -// TestServiceLanguageRoundTrip checks SetServiceLanguage persists the push-routing -// language (the bot a Telegram user last signed in through): a fresh account has -// none, a set value reads back, a later login overwrites it (last-login-wins), and -// an empty value is a no-op. The push-target route coalesces it with the preferred -// language. -func TestServiceLanguageRoundTrip(t *testing.T) { - ctx := context.Background() - store := account.NewStore(testDB) - acc, err := store.ProvisionTelegram(ctx, "tg-"+uuid.NewString(), "en", "", "Player") - if err != nil { - t.Fatalf("provision telegram: %v", err) - } - if acc.ServiceLanguage != "" { - t.Errorf("fresh ServiceLanguage = %q, want empty", acc.ServiceLanguage) - } - - if err := store.SetServiceLanguage(ctx, acc.ID, "ru"); err != nil { - t.Fatalf("set service language: %v", err) - } - if got, err := store.GetByID(ctx, acc.ID); err != nil { - t.Fatalf("get by id: %v", err) - } else if got.ServiceLanguage != "ru" { - t.Errorf("ServiceLanguage = %q, want ru", got.ServiceLanguage) - } - - // A later login through the other bot updates it; a subsequent empty value - // (a non-Telegram login) leaves it unchanged. - if err := store.SetServiceLanguage(ctx, acc.ID, "en"); err != nil { - t.Fatalf("update service language: %v", err) - } - if err := store.SetServiceLanguage(ctx, acc.ID, ""); err != nil { - t.Fatalf("noop service language: %v", err) - } - if got, err := store.GetByID(ctx, acc.ID); err != nil { - t.Fatalf("get by id: %v", err) - } else if got.ServiceLanguage != "en" { - t.Errorf("ServiceLanguage after update+noop = %q, want en", got.ServiceLanguage) - } -} - // TestHighRateFlagRoundTrip covers the soft high-rate marker: a fresh account // is unflagged, FlagHighRate stamps it exactly once (a second sustained episode // never moves the timestamp), ClearHighRateFlag reverses it, and a re-flag after @@ -299,6 +259,7 @@ func TestNotificationsInAppOnlyRoundTrip(t *testing.T) { PreferredLanguage: "en", TimeZone: "UTC", NotificationsInAppOnly: false, + VariantPreferences: []string{"erudit_ru"}, }) if err != nil { t.Fatalf("update profile: %v", err) diff --git a/backend/internal/inttest/banner_console_test.go b/backend/internal/inttest/banner_console_test.go index 8c33350..d858213 100644 --- a/backend/internal/inttest/banner_console_test.go +++ b/backend/internal/inttest/banner_console_test.go @@ -256,7 +256,8 @@ func TestBannerSurvivesProfileUpdate(t *testing.T) { id := provisionAccount(t) body := `{"display_name":"Tester","preferred_language":"ru","time_zone":"UTC","away_start":"00:00",` + - `"away_end":"00:00","block_chat":false,"block_friend_requests":false,"notifications_in_app_only":true}` + `"away_end":"00:00","block_chat":false,"block_friend_requests":false,"notifications_in_app_only":true,` + + `"variant_preferences":["erudit_ru"]}` rec := httptest.NewRecorder() req := httptest.NewRequest(http.MethodPut, "/api/v1/user/profile", strings.NewReader(body)) req.Header.Set("X-User-ID", id.String()) diff --git a/backend/internal/inttest/email_test.go b/backend/internal/inttest/email_test.go index e30ccc6..97d8d5e 100644 --- a/backend/internal/inttest/email_test.go +++ b/backend/internal/inttest/email_test.go @@ -6,6 +6,7 @@ import ( "context" "errors" "regexp" + "slices" "testing" "time" @@ -134,12 +135,20 @@ func TestUpdateProfilePersists(t *testing.T) { store := account.NewStore(testDB) acc := provisionAccount(t) + // A fresh account defaults to Erudit only (the DB-level column default). + if def, err := store.GetByID(ctx, acc); err != nil { + t.Fatalf("get default: %v", err) + } else if want := []string{"erudit_ru"}; !slices.Equal(def.VariantPreferences, want) { + t.Errorf("default variant preferences = %v, want %v", def.VariantPreferences, want) + } + updated, err := store.UpdateProfile(ctx, acc, account.ProfileUpdate{ DisplayName: "Kaya", PreferredLanguage: "ru", TimeZone: "Europe/Moscow", BlockChat: true, BlockFriendRequests: true, + VariantPreferences: []string{"scrabble_en", "erudit_ru"}, }) if err != nil { t.Fatalf("update profile: %v", err) @@ -157,6 +166,10 @@ func TestUpdateProfilePersists(t *testing.T) { if reloaded.TimeZone != "Europe/Moscow" || !reloaded.BlockChat { t.Errorf("profile did not persist: %+v", reloaded) } + // The text[] column round-trips and is stored canonically (Erudit-first). + if want := []string{"erudit_ru", "scrabble_en"}; !slices.Equal(reloaded.VariantPreferences, want) { + t.Errorf("variant preferences = %v, want %v", reloaded.VariantPreferences, want) + } } // TestUpdateProfileOffsetTimezone checks the UTC-offset timezone: it is @@ -167,9 +180,10 @@ func TestUpdateProfileOffsetTimezone(t *testing.T) { acc := provisionAccount(t) updated, err := store.UpdateProfile(ctx, acc, account.ProfileUpdate{ - DisplayName: "Kaya", - PreferredLanguage: "en", - TimeZone: "+03:00", + DisplayName: "Kaya", + PreferredLanguage: "en", + TimeZone: "+03:00", + VariantPreferences: []string{"erudit_ru"}, }) if err != nil { t.Fatalf("update with offset timezone: %v", err) diff --git a/backend/internal/inttest/feedback_test.go b/backend/internal/inttest/feedback_test.go index 6aadcfa..9d323a1 100644 --- a/backend/internal/inttest/feedback_test.go +++ b/backend/internal/inttest/feedback_test.go @@ -145,48 +145,33 @@ func TestFeedbackReplyHiddenAfterNewMessage(t *testing.T) { } } -func TestFeedbackSnapshotsLanguages(t *testing.T) { +func TestFeedbackSnapshotsLanguage(t *testing.T) { ctx := context.Background() svc := newFeedbackService() acc := provisionAccount(t) if _, err := testDB.ExecContext(ctx, - `UPDATE backend.accounts SET preferred_language = 'en', service_language = 'ru' WHERE account_id = $1`, acc); err != nil { - t.Fatalf("set languages: %v", err) + `UPDATE backend.accounts SET preferred_language = 'en' WHERE account_id = $1`, acc); err != nil { + t.Fatalf("set language: %v", err) } - // A Telegram (connector) message snapshots both the interface language and the bot. + // A message snapshots the sender's interface language at submit time. if err := svc.Submit(ctx, acc, "from telegram", nil, "", "telegram", ""); err != nil { t.Fatalf("submit: %v", err) } id := latestFeedbackID(t, svc, acc) if m, err := svc.AdminGet(ctx, id); err != nil { t.Fatalf("admin get: %v", err) - } else if m.Lang != "en" || m.ChannelLang != "ru" { - t.Fatalf("snapshot = lang %q / channel_lang %q, want en / ru", m.Lang, m.ChannelLang) + } else if m.Lang != "en" { + t.Fatalf("snapshot = lang %q, want en", m.Lang) } // Changing the account afterwards must not change the stored snapshot. if _, err := testDB.ExecContext(ctx, - `UPDATE backend.accounts SET preferred_language = 'ru', service_language = 'en' WHERE account_id = $1`, acc); err != nil { - t.Fatalf("change languages: %v", err) + `UPDATE backend.accounts SET preferred_language = 'ru' WHERE account_id = $1`, acc); err != nil { + t.Fatalf("change language: %v", err) } if m, err := svc.AdminGet(ctx, id); err != nil { t.Fatal(err) - } else if m.Lang != "en" || m.ChannelLang != "ru" { - t.Fatalf("snapshot drifted after account change = lang %q / channel_lang %q", m.Lang, m.ChannelLang) - } - - // A non-connector channel records no bot language even when the account has one. - acc2 := provisionAccount(t) - if _, err := testDB.ExecContext(ctx, - `UPDATE backend.accounts SET preferred_language = 'en', service_language = 'ru' WHERE account_id = $1`, acc2); err != nil { - t.Fatalf("set languages 2: %v", err) - } - if err := svc.Submit(ctx, acc2, "from web", nil, "", "web", ""); err != nil { - t.Fatalf("submit web: %v", err) - } - if m, err := svc.AdminGet(ctx, latestFeedbackID(t, svc, acc2)); err != nil { - t.Fatal(err) - } else if m.Lang != "en" || m.ChannelLang != "" { - t.Fatalf("web snapshot = lang %q / channel_lang %q, want en / empty", m.Lang, m.ChannelLang) + } else if m.Lang != "en" { + t.Fatalf("snapshot drifted after account change = lang %q, want en", m.Lang) } } diff --git a/backend/internal/inttest/game_limit_test.go b/backend/internal/inttest/game_limit_test.go index 56b1574..7541184 100644 --- a/backend/internal/inttest/game_limit_test.go +++ b/backend/internal/inttest/game_limit_test.go @@ -97,10 +97,12 @@ func TestGameLimitGate(t *testing.T) { if !gamesListAtLimit(t, srv, human) { t.Fatalf("at %d games at_game_limit must be true", game.MaxActiveQuickGames) } - if rec := userPost(t, srv, "/api/v1/user/lobby/enqueue", human, `{"variant":"scrabble_en"}`); rec.Code != http.StatusConflict || errorCode(t, rec) != "game_limit_reached" { + // erudit_ru is in the default variant preferences, so the variant gate passes and the + // game-limit gate is what fires here. + if rec := userPost(t, srv, "/api/v1/user/lobby/enqueue", human, `{"variant":"erudit_ru"}`); rec.Code != http.StatusConflict || errorCode(t, rec) != "game_limit_reached" { t.Fatalf("enqueue at limit = (%d, %q), want (409, game_limit_reached)", rec.Code, errorCode(t, rec)) } - invBody := fmt.Sprintf(`{"variant":"scrabble_en","invitee_ids":[%q]}`, opp.String()) + invBody := fmt.Sprintf(`{"variant":"erudit_ru","invitee_ids":[%q]}`, opp.String()) if rec := userPost(t, srv, "/api/v1/user/invitations", human, invBody); rec.Code != http.StatusConflict || errorCode(t, rec) != "game_limit_reached" { t.Fatalf("invitation at limit = (%d, %q), want (409, game_limit_reached)", rec.Code, errorCode(t, rec)) } diff --git a/backend/internal/inttest/seat_display_name_test.go b/backend/internal/inttest/seat_display_name_test.go index 4c51020..905eef6 100644 --- a/backend/internal/inttest/seat_display_name_test.go +++ b/backend/internal/inttest/seat_display_name_test.go @@ -37,7 +37,7 @@ func TestSeatNameFrozenAfterRename(t *testing.T) { starter := provisionAccount(t) if _, err := accounts.UpdateProfile(ctx, starter, account.ProfileUpdate{ - DisplayName: "Original Name", PreferredLanguage: "en", TimeZone: "UTC", + DisplayName: "Original Name", PreferredLanguage: "en", TimeZone: "UTC", VariantPreferences: []string{"erudit_ru"}, }); err != nil { t.Fatalf("set name: %v", err) } @@ -50,7 +50,7 @@ func TestSeatNameFrozenAfterRename(t *testing.T) { // Rename the account; the snapshot on the already-taken seat must not follow. if _, err := accounts.UpdateProfile(ctx, starter, account.ProfileUpdate{ - DisplayName: "Renamed Player99", PreferredLanguage: "en", TimeZone: "UTC", + DisplayName: "Renamed Player99", PreferredLanguage: "en", TimeZone: "UTC", VariantPreferences: []string{"erudit_ru"}, }); err != nil { t.Fatalf("rename: %v", err) } diff --git a/backend/internal/inttest/social_test.go b/backend/internal/inttest/social_test.go index f6f9e84..6639ceb 100644 --- a/backend/internal/inttest/social_test.go +++ b/backend/internal/inttest/social_test.go @@ -135,7 +135,7 @@ func TestFriendRequestRefusedByToggleAndBlock(t *testing.T) { // Toggle: the addressee does not accept friend requests. a, b := provisionAccount(t), provisionAccount(t) - if _, err := store.UpdateProfile(ctx, b, account.ProfileUpdate{DisplayName: "Player", PreferredLanguage: "en", TimeZone: "UTC", BlockFriendRequests: true}); err != nil { + if _, err := store.UpdateProfile(ctx, b, account.ProfileUpdate{DisplayName: "Player", PreferredLanguage: "en", TimeZone: "UTC", BlockFriendRequests: true, VariantPreferences: []string{"erudit_ru"}}); err != nil { t.Fatalf("set toggle: %v", err) } if err := svc.SendFriendRequest(ctx, a, b); !errors.Is(err, social.ErrRequestBlocked) { @@ -353,7 +353,7 @@ func TestChatPostListAndBlocks(t *testing.T) { if _, err := svc.PostMessage(ctx, other, seats2[0], "hi", ""); err != nil { t.Fatalf("post 2: %v", err) } - if _, err := store.UpdateProfile(ctx, seats2[1], account.ProfileUpdate{DisplayName: "Player", PreferredLanguage: "en", TimeZone: "UTC", BlockChat: true}); err != nil { + if _, err := store.UpdateProfile(ctx, seats2[1], account.ProfileUpdate{DisplayName: "Player", PreferredLanguage: "en", TimeZone: "UTC", BlockChat: true, VariantPreferences: []string{"erudit_ru"}}); err != nil { t.Fatalf("set block_chat: %v", err) } if msgs, _ := svc.Messages(ctx, other, seats2[1]); len(msgs) != 0 { @@ -588,32 +588,6 @@ func TestRespondPublishesToRequester(t *testing.T) { } } -// TestNudgeRoutedByGameLanguage checks a nudge's out-of-app push carries the game's language, so -// it is delivered by the game's bot rather than the recipient's last-login bot. -func TestNudgeRoutedByGameLanguage(t *testing.T) { - ctx := context.Background() - svc := newSocialService() - pub := &capturePublisher{} - svc.SetNotifier(pub) - - gameID, seats := newGameWithSeats(t, 2) // an English game; seat 0 is to move - if _, err := svc.Nudge(ctx, gameID, seats[1]); err != nil { - t.Fatalf("nudge: %v", err) - } - found := false - for _, in := range pub.intents { - if in.Kind == notify.KindNudge { - found = true - if in.Language != "en" { - t.Errorf("nudge language = %q, want en (the game's language)", in.Language) - } - } - } - if !found { - t.Fatal("no nudge intent published") - } -} - // TestAdminListMessages checks the admin moderation list: real messages only // (nudges excluded), the game / sender pins, the sender glob masks, and the source label. func TestAdminListMessages(t *testing.T) { diff --git a/backend/internal/inttest/variant_preference_test.go b/backend/internal/inttest/variant_preference_test.go new file mode 100644 index 0000000..5e49a28 --- /dev/null +++ b/backend/internal/inttest/variant_preference_test.go @@ -0,0 +1,51 @@ +//go:build integration + +package inttest + +import ( + "fmt" + "net/http" + "testing" + "time" + + "go.uber.org/zap/zaptest" + + "scrabble/backend/internal/account" + "scrabble/backend/internal/server" +) + +// TestVariantPreferenceGate covers the New Game gate: a player may start a quick game +// or create a friend invitation only in a variant they have enabled in their profile +// (a fresh account defaults to Erudit only), and any other variant is refused with 400. +// The complementary case — an invited friend accepting an invitation in a variant they +// have NOT enabled — is exercised by TestGameLimitGate, where a default-Erudit human +// accepts an English invitation over HTTP. +func TestVariantPreferenceGate(t *testing.T) { + clearOpenGames(t) + srv := server.New(":0", server.Deps{ + Logger: zaptest.NewLogger(t), + DB: testDB, + Accounts: account.NewStore(testDB), + Games: newGameService(), + Matchmaker: newMatchmaker(t, newRobotService(t, newGameService()), time.Minute, 0), + Invitations: newInvitationService(), + }) + + human := provisionAccount(t) // default preferences: erudit_ru only + opp := provisionAccount(t) + + // A variant outside the player's preferences is refused on both create paths. + if rec := userPost(t, srv, "/api/v1/user/lobby/enqueue", human, `{"variant":"scrabble_en"}`); rec.Code != http.StatusBadRequest { + t.Fatalf("enqueue non-preferred variant = %d (%s), want 400", rec.Code, rec.Body.String()) + } + invBody := fmt.Sprintf(`{"variant":"scrabble_en","invitee_ids":[%q]}`, opp.String()) + if rec := userPost(t, srv, "/api/v1/user/invitations", human, invBody); rec.Code != http.StatusBadRequest { + t.Fatalf("invitation non-preferred variant = %d (%s), want 400", rec.Code, rec.Body.String()) + } + + // The default-enabled variant (Erudit) is allowed: the quick enqueue opens a game. + if rec := userPost(t, srv, "/api/v1/user/lobby/enqueue", human, `{"variant":"erudit_ru"}`); rec.Code != http.StatusOK { + t.Fatalf("enqueue preferred variant = %d (%s), want 200", rec.Code, rec.Body.String()) + } + clearOpenGames(t) +} diff --git a/backend/internal/lobby/matchmaker.go b/backend/internal/lobby/matchmaker.go index 54e9b16..6c52e68 100644 --- a/backend/internal/lobby/matchmaker.go +++ b/backend/internal/lobby/matchmaker.go @@ -206,7 +206,6 @@ func (m *Matchmaker) announceOpponent(ctx context.Context, g game.Game, joinerID return } intent := notify.OpponentJoined(starter, g.ID, state) - intent.Language = g.Variant.Language() m.pub.Publish(intent) } diff --git a/backend/internal/notify/notify.go b/backend/internal/notify/notify.go index 9e74774..583987a 100644 --- a/backend/internal/notify/notify.go +++ b/backend/internal/notify/notify.go @@ -82,11 +82,6 @@ type Intent struct { Kind string Payload []byte EventID string - // Language routes an out-of-app push to a specific per-language bot: for a - // game event it is the game's language ("en"/"ru"), so the notification comes from the - // game's bot rather than the recipient's last-login bot. Empty falls back to the - // recipient's service language at the gateway. - Language string } // Publisher accepts live-event intents. Implementations must be safe for diff --git a/backend/internal/postgres/jet/backend/model/accounts.go b/backend/internal/postgres/jet/backend/model/accounts.go index ae26769..c69445d 100644 --- a/backend/internal/postgres/jet/backend/model/accounts.go +++ b/backend/internal/postgres/jet/backend/model/accounts.go @@ -9,6 +9,7 @@ package model import ( "github.com/google/uuid" + "github.com/lib/pq" "time" ) @@ -29,6 +30,6 @@ type Accounts struct { PaidAccount bool MergedInto *uuid.UUID MergedAt *time.Time - ServiceLanguage *string FlaggedHighRateAt *time.Time + VariantPreferences pq.StringArray } diff --git a/backend/internal/postgres/jet/backend/model/feedback_messages.go b/backend/internal/postgres/jet/backend/model/feedback_messages.go index ef0dff8..32bbdaa 100644 --- a/backend/internal/postgres/jet/backend/model/feedback_messages.go +++ b/backend/internal/postgres/jet/backend/model/feedback_messages.go @@ -20,12 +20,11 @@ type FeedbackMessages struct { AttachmentName *string SenderIP *string Channel string - Lang *string - ChannelLang *string ReadAt *time.Time ArchivedAt *time.Time ReplyBody *string RepliedAt *time.Time ReplyReadAt *time.Time CreatedAt time.Time + Lang *string } diff --git a/backend/internal/postgres/jet/backend/table/accounts.go b/backend/internal/postgres/jet/backend/table/accounts.go index 021e7a4..3cafd35 100644 --- a/backend/internal/postgres/jet/backend/table/accounts.go +++ b/backend/internal/postgres/jet/backend/table/accounts.go @@ -33,8 +33,8 @@ type accountsTable struct { PaidAccount postgres.ColumnBool MergedInto postgres.ColumnString MergedAt postgres.ColumnTimestampz - ServiceLanguage postgres.ColumnString FlaggedHighRateAt postgres.ColumnTimestampz + VariantPreferences postgres.ColumnStringArray AllColumns postgres.ColumnList MutableColumns postgres.ColumnList @@ -92,11 +92,11 @@ func newAccountsTableImpl(schemaName, tableName, alias string) accountsTable { PaidAccountColumn = postgres.BoolColumn("paid_account") MergedIntoColumn = postgres.StringColumn("merged_into") MergedAtColumn = postgres.TimestampzColumn("merged_at") - ServiceLanguageColumn = postgres.StringColumn("service_language") FlaggedHighRateAtColumn = postgres.TimestampzColumn("flagged_high_rate_at") - allColumns = postgres.ColumnList{AccountIDColumn, DisplayNameColumn, PreferredLanguageColumn, TimeZoneColumn, BlockChatColumn, BlockFriendRequestsColumn, CreatedAtColumn, UpdatedAtColumn, AwayStartColumn, AwayEndColumn, HintBalanceColumn, IsGuestColumn, NotificationsInAppOnlyColumn, PaidAccountColumn, MergedIntoColumn, MergedAtColumn, ServiceLanguageColumn, FlaggedHighRateAtColumn} - mutableColumns = postgres.ColumnList{DisplayNameColumn, PreferredLanguageColumn, TimeZoneColumn, BlockChatColumn, BlockFriendRequestsColumn, CreatedAtColumn, UpdatedAtColumn, AwayStartColumn, AwayEndColumn, HintBalanceColumn, IsGuestColumn, NotificationsInAppOnlyColumn, PaidAccountColumn, MergedIntoColumn, MergedAtColumn, ServiceLanguageColumn, FlaggedHighRateAtColumn} - defaultColumns = postgres.ColumnList{DisplayNameColumn, PreferredLanguageColumn, TimeZoneColumn, BlockChatColumn, BlockFriendRequestsColumn, CreatedAtColumn, UpdatedAtColumn, AwayStartColumn, AwayEndColumn, HintBalanceColumn, IsGuestColumn, NotificationsInAppOnlyColumn, PaidAccountColumn} + VariantPreferencesColumn = postgres.StringArrayColumn("variant_preferences") + allColumns = postgres.ColumnList{AccountIDColumn, DisplayNameColumn, PreferredLanguageColumn, TimeZoneColumn, BlockChatColumn, BlockFriendRequestsColumn, CreatedAtColumn, UpdatedAtColumn, AwayStartColumn, AwayEndColumn, HintBalanceColumn, IsGuestColumn, NotificationsInAppOnlyColumn, PaidAccountColumn, MergedIntoColumn, MergedAtColumn, FlaggedHighRateAtColumn, VariantPreferencesColumn} + mutableColumns = postgres.ColumnList{DisplayNameColumn, PreferredLanguageColumn, TimeZoneColumn, BlockChatColumn, BlockFriendRequestsColumn, CreatedAtColumn, UpdatedAtColumn, AwayStartColumn, AwayEndColumn, HintBalanceColumn, IsGuestColumn, NotificationsInAppOnlyColumn, PaidAccountColumn, MergedIntoColumn, MergedAtColumn, FlaggedHighRateAtColumn, VariantPreferencesColumn} + defaultColumns = postgres.ColumnList{DisplayNameColumn, PreferredLanguageColumn, TimeZoneColumn, BlockChatColumn, BlockFriendRequestsColumn, CreatedAtColumn, UpdatedAtColumn, AwayStartColumn, AwayEndColumn, HintBalanceColumn, IsGuestColumn, NotificationsInAppOnlyColumn, PaidAccountColumn, VariantPreferencesColumn} ) return accountsTable{ @@ -119,8 +119,8 @@ func newAccountsTableImpl(schemaName, tableName, alias string) accountsTable { PaidAccount: PaidAccountColumn, MergedInto: MergedIntoColumn, MergedAt: MergedAtColumn, - ServiceLanguage: ServiceLanguageColumn, FlaggedHighRateAt: FlaggedHighRateAtColumn, + VariantPreferences: VariantPreferencesColumn, AllColumns: allColumns, MutableColumns: mutableColumns, diff --git a/backend/internal/postgres/jet/backend/table/feedback_messages.go b/backend/internal/postgres/jet/backend/table/feedback_messages.go index 7b16c19..238c640 100644 --- a/backend/internal/postgres/jet/backend/table/feedback_messages.go +++ b/backend/internal/postgres/jet/backend/table/feedback_messages.go @@ -24,14 +24,13 @@ type feedbackMessagesTable struct { AttachmentName postgres.ColumnString SenderIP postgres.ColumnString Channel postgres.ColumnString - Lang postgres.ColumnString - ChannelLang postgres.ColumnString ReadAt postgres.ColumnTimestampz ArchivedAt postgres.ColumnTimestampz ReplyBody postgres.ColumnString RepliedAt postgres.ColumnTimestampz ReplyReadAt postgres.ColumnTimestampz CreatedAt postgres.ColumnTimestampz + Lang postgres.ColumnString AllColumns postgres.ColumnList MutableColumns postgres.ColumnList @@ -80,16 +79,15 @@ func newFeedbackMessagesTableImpl(schemaName, tableName, alias string) feedbackM AttachmentNameColumn = postgres.StringColumn("attachment_name") SenderIPColumn = postgres.StringColumn("sender_ip") ChannelColumn = postgres.StringColumn("channel") - LangColumn = postgres.StringColumn("lang") - ChannelLangColumn = postgres.StringColumn("channel_lang") ReadAtColumn = postgres.TimestampzColumn("read_at") ArchivedAtColumn = postgres.TimestampzColumn("archived_at") ReplyBodyColumn = postgres.StringColumn("reply_body") RepliedAtColumn = postgres.TimestampzColumn("replied_at") ReplyReadAtColumn = postgres.TimestampzColumn("reply_read_at") CreatedAtColumn = postgres.TimestampzColumn("created_at") - allColumns = postgres.ColumnList{MessageIDColumn, AccountIDColumn, BodyColumn, AttachmentColumn, AttachmentNameColumn, SenderIPColumn, ChannelColumn, LangColumn, ChannelLangColumn, ReadAtColumn, ArchivedAtColumn, ReplyBodyColumn, RepliedAtColumn, ReplyReadAtColumn, CreatedAtColumn} - mutableColumns = postgres.ColumnList{AccountIDColumn, BodyColumn, AttachmentColumn, AttachmentNameColumn, SenderIPColumn, ChannelColumn, LangColumn, ChannelLangColumn, ReadAtColumn, ArchivedAtColumn, ReplyBodyColumn, RepliedAtColumn, ReplyReadAtColumn, CreatedAtColumn} + LangColumn = postgres.StringColumn("lang") + allColumns = postgres.ColumnList{MessageIDColumn, AccountIDColumn, BodyColumn, AttachmentColumn, AttachmentNameColumn, SenderIPColumn, ChannelColumn, ReadAtColumn, ArchivedAtColumn, ReplyBodyColumn, RepliedAtColumn, ReplyReadAtColumn, CreatedAtColumn, LangColumn} + mutableColumns = postgres.ColumnList{AccountIDColumn, BodyColumn, AttachmentColumn, AttachmentNameColumn, SenderIPColumn, ChannelColumn, ReadAtColumn, ArchivedAtColumn, ReplyBodyColumn, RepliedAtColumn, ReplyReadAtColumn, CreatedAtColumn, LangColumn} defaultColumns = postgres.ColumnList{CreatedAtColumn} ) @@ -104,14 +102,13 @@ func newFeedbackMessagesTableImpl(schemaName, tableName, alias string) feedbackM AttachmentName: AttachmentNameColumn, SenderIP: SenderIPColumn, Channel: ChannelColumn, - Lang: LangColumn, - ChannelLang: ChannelLangColumn, ReadAt: ReadAtColumn, ArchivedAt: ArchivedAtColumn, ReplyBody: ReplyBodyColumn, RepliedAt: RepliedAtColumn, ReplyReadAt: ReplyReadAtColumn, CreatedAt: CreatedAtColumn, + Lang: LangColumn, AllColumns: allColumns, MutableColumns: mutableColumns, diff --git a/backend/internal/postgres/migrations/00014_single_bot_variant_preferences.sql b/backend/internal/postgres/migrations/00014_single_bot_variant_preferences.sql new file mode 100644 index 0000000..421d49e --- /dev/null +++ b/backend/internal/postgres/migrations/00014_single_bot_variant_preferences.sql @@ -0,0 +1,45 @@ +-- +goose Up +-- Single-bot collapse + per-user variant preferences. +-- +-- With one Telegram bot there is no longer a "service language" (which bot a player +-- signed in through), and variant availability is no longer gated by the bot's +-- supported languages but by an explicit per-account preference. variant_preferences +-- is the set of game variants (engine.Variant stable labels) a player is willing to be +-- matched into: it gates the New Game picker and the matchmaker, while an invited friend +-- may still accept any variant. New accounts default to Erudit only (a DB-level default, +-- so no application seed is needed); the set may never be empty and must be a subset of +-- the three known variants. feedback_messages.channel_lang (the bot a message arrived +-- through) likewise loses meaning under one bot and is dropped; the sender's interface +-- language (lang) is kept. +SET search_path = backend, pg_catalog; + +ALTER TABLE accounts + ADD COLUMN variant_preferences text[] NOT NULL DEFAULT ARRAY['erudit_ru']::text[], + ADD CONSTRAINT accounts_variant_preferences_nonempty_chk + CHECK (cardinality(variant_preferences) >= 1), + ADD CONSTRAINT accounts_variant_preferences_subset_chk + CHECK (variant_preferences <@ ARRAY['scrabble_en', 'scrabble_ru', 'erudit_ru']::text[]); + +ALTER TABLE accounts DROP COLUMN service_language; + +ALTER TABLE feedback_messages DROP COLUMN channel_lang; + +-- The auto-match pairing query filters open games by (variant, multiple_words_per_turn) +-- and takes the oldest by created_at; games_open_idx (open_deadline_at) does not serve it. +-- A partial index over open games turns the scan-and-sort into a single index seek. +CREATE INDEX games_open_match_idx ON games (variant, multiple_words_per_turn, created_at) + WHERE status = 'open'; + +-- +goose Down +SET search_path = backend, pg_catalog; + +DROP INDEX games_open_match_idx; + +ALTER TABLE feedback_messages ADD COLUMN channel_lang text; + +ALTER TABLE accounts ADD COLUMN service_language text CHECK (service_language IN ('en', 'ru')); + +ALTER TABLE accounts + DROP CONSTRAINT accounts_variant_preferences_subset_chk, + DROP CONSTRAINT accounts_variant_preferences_nonempty_chk, + DROP COLUMN variant_preferences; diff --git a/backend/internal/pushgrpc/server.go b/backend/internal/pushgrpc/server.go index 5bb4661..8a3dcad 100644 --- a/backend/internal/pushgrpc/server.go +++ b/backend/internal/pushgrpc/server.go @@ -54,11 +54,10 @@ func (s *Service) Subscribe(req *pushv1.SubscribeRequest, stream grpc.ServerStre return nil } ev := &pushv1.Event{ - UserId: in.UserID.String(), - Kind: in.Kind, - Payload: in.Payload, - EventId: in.EventID, - Language: in.Language, + UserId: in.UserID.String(), + Kind: in.Kind, + Payload: in.Payload, + EventId: in.EventID, } if err := stream.Send(ev); err != nil { return err diff --git a/backend/internal/server/banner.go b/backend/internal/server/banner.go index af91626..c87d70d 100644 --- a/backend/internal/server/banner.go +++ b/backend/internal/server/banner.go @@ -88,13 +88,9 @@ func (s *Server) bannerFor(ctx context.Context, acc account.Account) *bannerDTO } } -// bannerLang resolves the message language for a viewer: the bot (service) -// language they last signed in through, falling back to the interface language -// and then English. +// bannerLang resolves the message language for a viewer: their interface language +// (Russian, or English by default). func bannerLang(acc account.Account) string { - if acc.ServiceLanguage == "ru" || acc.ServiceLanguage == "en" { - return acc.ServiceLanguage - } if acc.PreferredLanguage == "ru" { return "ru" } diff --git a/backend/internal/server/dto.go b/backend/internal/server/dto.go index 68ba1e7..9b97885 100644 --- a/backend/internal/server/dto.go +++ b/backend/internal/server/dto.go @@ -16,11 +16,10 @@ import ( // sessionResponse is the credential returned by every auth endpoint. type sessionResponse struct { - Token string `json:"token"` - UserID string `json:"user_id"` - IsGuest bool `json:"is_guest"` - DisplayName string `json:"display_name"` - ServiceLanguage string `json:"service_language"` + Token string `json:"token"` + UserID string `json:"user_id"` + IsGuest bool `json:"is_guest"` + DisplayName string `json:"display_name"` } // okResponse is a simple success acknowledgement. @@ -49,6 +48,10 @@ type profileResponse struct { BlockFriendRequests bool `json:"block_friend_requests"` IsGuest bool `json:"is_guest"` NotificationsInAppOnly bool `json:"notifications_in_app_only"` + // VariantPreferences is the set of game variants the player allows themselves to + // be matched into (engine.Variant stable labels), Erudit-first. It gates the New + // Game picker and the matchmaker; never empty. + VariantPreferences []string `json:"variant_preferences"` // Banner is the advertising-banner block: present only for a viewer eligible to // see the banner (a free account with an empty hint wallet and without the // no_banner role), absent otherwise. See banner.go. @@ -177,11 +180,10 @@ type errorBody struct { // sessionResponseFor builds the credential payload for a minted session. func sessionResponseFor(token string, acc account.Account) sessionResponse { return sessionResponse{ - Token: token, - UserID: acc.ID.String(), - IsGuest: acc.IsGuest, - DisplayName: acc.DisplayName, - ServiceLanguage: acc.ServiceLanguage, + Token: token, + UserID: acc.ID.String(), + IsGuest: acc.IsGuest, + DisplayName: acc.DisplayName, } } @@ -199,6 +201,7 @@ func profileResponseFor(acc account.Account) profileResponse { BlockFriendRequests: acc.BlockFriendRequests, IsGuest: acc.IsGuest, NotificationsInAppOnly: acc.NotificationsInAppOnly, + VariantPreferences: acc.VariantPreferences, } } diff --git a/backend/internal/server/handlers_account.go b/backend/internal/server/handlers_account.go index 7df096c..ed3a3c7 100644 --- a/backend/internal/server/handlers_account.go +++ b/backend/internal/server/handlers_account.go @@ -18,14 +18,15 @@ import ( // updateProfileRequest is the full editable profile. away_start/away_end are // "HH:MM" local-time bounds of the daily away window. type updateProfileRequest struct { - DisplayName string `json:"display_name"` - PreferredLanguage string `json:"preferred_language"` - TimeZone string `json:"time_zone"` - AwayStart string `json:"away_start"` - AwayEnd string `json:"away_end"` - BlockChat bool `json:"block_chat"` - BlockFriendRequests bool `json:"block_friend_requests"` - NotificationsInAppOnly bool `json:"notifications_in_app_only"` + DisplayName string `json:"display_name"` + PreferredLanguage string `json:"preferred_language"` + TimeZone string `json:"time_zone"` + AwayStart string `json:"away_start"` + AwayEnd string `json:"away_end"` + BlockChat bool `json:"block_chat"` + BlockFriendRequests bool `json:"block_friend_requests"` + NotificationsInAppOnly bool `json:"notifications_in_app_only"` + VariantPreferences []string `json:"variant_preferences"` } // statsDTO is a durable account's lifetime statistics (the derived games-played and @@ -92,6 +93,7 @@ func (s *Server) handleUpdateProfile(c *gin.Context) { BlockChat: req.BlockChat, BlockFriendRequests: req.BlockFriendRequests, NotificationsInAppOnly: req.NotificationsInAppOnly, + VariantPreferences: req.VariantPreferences, }) if err != nil { s.abortErr(c, err) diff --git a/backend/internal/server/handlers_admin_console.go b/backend/internal/server/handlers_admin_console.go index c7a1013..fac9fde 100644 --- a/backend/internal/server/handlers_admin_console.go +++ b/backend/internal/server/handlers_admin_console.go @@ -424,7 +424,6 @@ func (s *Server) consoleUserMessage(c *gin.Context) { } back := "/_gm/users/" + id.String() text := trimForm(c, "text") - language := trimForm(c, "language") switch { case text == "": s.renderConsoleMessage(c, "Nothing sent", "the message was empty", back) @@ -436,14 +435,14 @@ func (s *Server) consoleUserMessage(c *gin.Context) { s.renderConsoleMessage(c, "No Telegram", "this account has no Telegram identity", back) return } - delivered, err := s.connector.SendToUser(ctx, ext, text, language) + delivered, err := s.connector.SendToUser(ctx, ext, text) if err != nil { s.consoleError(c, err) return } body := "message delivered" if !delivered { - body = "not delivered (the user may not have started that bot)" + body = "not delivered (the user may not have started the bot)" } s.renderConsoleMessage(c, "Sent", body, back) } @@ -833,21 +832,20 @@ func (s *Server) consoleBroadcast(c *gin.Context) { // consolePostBroadcast posts an operator message to the connector's game channel. func (s *Server) consolePostBroadcast(c *gin.Context) { text := trimForm(c, "text") - language := trimForm(c, "language") switch { case text == "": s.renderConsoleMessage(c, "Nothing sent", "the message was empty", "/_gm/broadcast") case s.connector == nil: s.renderConsoleMessage(c, "Not configured", "the connector is not configured (set BACKEND_CONNECTOR_ADDR)", "/_gm/broadcast") default: - delivered, err := s.connector.SendToGameChannel(c.Request.Context(), text, language) + delivered, err := s.connector.SendToGameChannel(c.Request.Context(), text) if err != nil { s.consoleError(c, err) return } body := "posted to the game channel" if !delivered { - body = "not delivered (that bot has no game channel configured)" + body = "not delivered (the bot has no game channel configured)" } s.renderConsoleMessage(c, "Broadcast", body, "/_gm/broadcast") } diff --git a/backend/internal/server/handlers_admin_feedback.go b/backend/internal/server/handlers_admin_feedback.go index 4a04384..582e6fe 100644 --- a/backend/internal/server/handlers_admin_feedback.go +++ b/backend/internal/server/handlers_admin_feedback.go @@ -79,7 +79,7 @@ func (s *Server) consoleFeedbackDetail(c *gin.Context) { } view := adminconsole.FeedbackDetailView{ ID: m.ID.String(), AccountID: m.AccountID.String(), SenderName: m.SenderName, - Source: m.Source, Channel: m.Channel, InterfaceLanguage: m.Lang, BotLanguage: m.ChannelLang, + Source: m.Source, Channel: m.Channel, InterfaceLanguage: m.Lang, IP: m.SenderIP, Body: m.Body, HasAttachment: m.HasAttachment, AttachmentName: m.AttachmentName, IsImage: feedback.IsImage(m.AttachmentName), Read: m.Read, Archived: m.Archived, Replied: m.Replied, ReplyBody: m.ReplyBody, diff --git a/backend/internal/server/handlers_auth.go b/backend/internal/server/handlers_auth.go index 1fed516..59bc100 100644 --- a/backend/internal/server/handlers_auth.go +++ b/backend/internal/server/handlers_auth.go @@ -19,20 +19,16 @@ import ( // telegramAuthRequest carries the identity the connector extracted from a // validated initData payload. Username, FirstName and LanguageCode seed a // brand-new account's display name and language (first contact only). -// ServiceLanguage is the validating bot's language tag (en/ru); it is recorded on -// every login (the bot the user last came through) and routes their out-of-app push. type telegramAuthRequest struct { - ExternalID string `json:"external_id"` - Username string `json:"username"` - FirstName string `json:"first_name"` - LanguageCode string `json:"language_code"` - ServiceLanguage string `json:"service_language"` + ExternalID string `json:"external_id"` + Username string `json:"username"` + FirstName string `json:"first_name"` + LanguageCode string `json:"language_code"` } // handleTelegramAuth provisions (or finds) the account bound to a Telegram // identity and mints a session for it, seeding a new account's display name and -// language from the supplied Telegram fields and recording the validating bot's -// service language (updated every login) so out-of-app push routes to that bot. +// language from the supplied Telegram fields (first contact only). func (s *Server) handleTelegramAuth(c *gin.Context) { var req telegramAuthRequest if err := c.ShouldBindJSON(&req); err != nil || req.ExternalID == "" { @@ -44,11 +40,6 @@ func (s *Server) handleTelegramAuth(c *gin.Context) { s.abortErr(c, err) return } - if err := s.accounts.SetServiceLanguage(c.Request.Context(), acc.ID, req.ServiceLanguage); err != nil { - s.abortErr(c, err) - return - } - acc.ServiceLanguage = req.ServiceLanguage // reflect this login's bot in the session response s.mintSession(c, acc) } @@ -59,10 +50,9 @@ type pushTargetRequest struct { // pushTargetResponse carries what the gateway needs to route an out-of-app push: // the recipient's Telegram external_id (empty when they have no Telegram -// identity, e.g. a guest or email-only account), the language that both selects the -// delivering bot and renders the message (the account's service language, the bot -// it last signed in through, falling back to its preferred language), and whether -// they confined notifications to the in-app stream. +// identity, e.g. a guest or email-only account), the language the single bot renders +// the message in (the account's interface language), and whether they confined +// notifications to the in-app stream. type pushTargetResponse struct { ExternalID string `json:"external_id"` Language string `json:"language"` @@ -94,15 +84,9 @@ func (s *Server) handlePushTarget(c *gin.Context) { s.abortErr(c, err) return } - // Route by the bot the user last signed in through; fall back to the interface - // language for an account that has never come through a tagged bot. - language := acc.ServiceLanguage - if language == "" { - language = acc.PreferredLanguage - } c.JSON(http.StatusOK, pushTargetResponse{ ExternalID: ext, - Language: language, + Language: acc.PreferredLanguage, NotificationsInAppOnly: acc.NotificationsInAppOnly, }) } diff --git a/backend/internal/server/handlers_invitations.go b/backend/internal/server/handlers_invitations.go index d6614ad..98a9ce3 100644 --- a/backend/internal/server/handlers_invitations.go +++ b/backend/internal/server/handlers_invitations.go @@ -104,6 +104,9 @@ func (s *Server) handleCreateInvitation(c *gin.Context) { abortBadRequest(c, "unknown variant") return } + if !s.ensureVariantAllowed(c, uid, variant.String()) { + return + } settings := lobby.InvitationSettings{ Variant: variant, HintsAllowed: req.HintsAllowed, diff --git a/backend/internal/server/handlers_user.go b/backend/internal/server/handlers_user.go index e15e041..9faf71e 100644 --- a/backend/internal/server/handlers_user.go +++ b/backend/internal/server/handlers_user.go @@ -2,8 +2,10 @@ package server import ( "net/http" + "slices" "github.com/gin-gonic/gin" + "github.com/google/uuid" "scrabble/backend/internal/engine" ) @@ -134,6 +136,24 @@ func (s *Server) handleGameState(c *gin.Context) { c.JSON(http.StatusOK, dto) } +// ensureVariantAllowed reports whether the caller's profile permits creating a game +// of variant — it must be one of their VariantPreferences. It aborts the request +// with 400 and returns false otherwise. Only the player who creates a game (quick +// match, vs-AI or a friend invitation) is gated this way; an invited friend may +// accept an invitation in any variant. +func (s *Server) ensureVariantAllowed(c *gin.Context, uid uuid.UUID, variant string) bool { + acc, err := s.accounts.GetByID(c.Request.Context(), uid) + if err != nil { + s.abortErr(c, err) + return false + } + if !slices.Contains(acc.VariantPreferences, variant) { + abortBadRequest(c, "variant is not in your preferences") + return false + } + return true +} + // enqueueRequest enters per-variant auto-match under a per-turn word rule. VsAI true // starts an honest-AI game against a robot instead of the open/wait matchmaking path. type enqueueRequest struct { @@ -162,6 +182,9 @@ func (s *Server) handleEnqueue(c *gin.Context) { abortBadRequest(c, "unknown variant") return } + if !s.ensureVariantAllowed(c, uid, variant.String()) { + return + } if !s.ensureUnderGameLimit(c, uid) { return } diff --git a/backend/internal/social/chat.go b/backend/internal/social/chat.go index 27e8329..3c5bd7f 100644 --- a/backend/internal/social/chat.go +++ b/backend/internal/social/chat.go @@ -206,9 +206,6 @@ func (svc *Service) Nudge(ctx context.Context, gameID, senderID uuid.UUID) (Mess // read "