Bookmark games

lib/src/model/auth/auth_session.dart

@@ -1,3 +1,4 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 import 'package:lichess_mobile/src/model/auth/session_storage.dart';
 import 'package:lichess_mobile/src/model/common/preloaded_data.dart';
@@ -34,3 +35,8 @@ class AuthSessionState with _$AuthSessionState {
 
   factory AuthSessionState.fromJson(Map<String, dynamic> json) => _$AuthSessionStateFromJson(json);
 }
+
+@riverpod
+bool isLoggedIn(Ref ref) {
+  return ref.watch(authSessionProvider.select((authSession) => authSession != null));
+}

lib/src/model/game/archived_game.dart

@@ -57,8 +57,8 @@ class ArchivedGame with _$ArchivedGame, BaseGame, IndexableSteps implements Base
   ///
   /// Currently, those endpoints are supported:
   /// - GET /game/export/<id>
-  factory ArchivedGame.fromServerJson(Map<String, dynamic> json) {
-    return _archivedGameFromPick(pick(json).required());
+  factory ArchivedGame.fromServerJson(Map<String, dynamic> json, {bool withBookmarked = false}) {
+    return _archivedGameFromPick(pick(json).required(), withBookmarked: withBookmarked);
   }
 
   /// Create an archived game from a local storage JSON.
@@ -99,10 +99,14 @@ class LightArchivedGame with _$LightArchivedGame {
     @MoveConverter() Move? lastMove,
     Side? winner,
     ClockData? clock,
+    bool? bookmarked,
   }) = _ArchivedGameData;
 
-  factory LightArchivedGame.fromServerJson(Map<String, dynamic> json) {
-    return _lightArchivedGameFromPick(pick(json).required());
+  factory LightArchivedGame.fromServerJson(
+    Map<String, dynamic> json, {
+    bool withBookmarked = false,
+  }) {
+    return _lightArchivedGameFromPick(pick(json).required(), withBookmarked: withBookmarked);
   }
 
   factory LightArchivedGame.fromJson(Map<String, dynamic> json) =>
@@ -129,8 +133,8 @@ IList<ExternalEval>? gameEvalsFromPick(RequiredPick pick) {
       ?.lock;
 }
 
-ArchivedGame _archivedGameFromPick(RequiredPick pick) {
-  final data = _lightArchivedGameFromPick(pick);
+ArchivedGame _archivedGameFromPick(RequiredPick pick, {bool withBookmarked = false}) {
+  final data = _lightArchivedGameFromPick(pick, withBookmarked: withBookmarked);
   final clocks = pick(
     'clocks',
   ).asListOrNull<Duration>((p0) => Duration(milliseconds: p0.asIntOrThrow() * 10));
@@ -202,7 +206,7 @@ ArchivedGame _archivedGameFromPick(RequiredPick pick) {
   );
 }
 
-LightArchivedGame _lightArchivedGameFromPick(RequiredPick pick) {
+LightArchivedGame _lightArchivedGameFromPick(RequiredPick pick, {bool withBookmarked = false}) {
   return LightArchivedGame(
     id: pick('id').asGameIdOrThrow(),
     fullId: pick('fullId').asGameFullIdOrNull(),
@@ -223,6 +227,7 @@ LightArchivedGame _lightArchivedGameFromPick(RequiredPick pick) {
     lastMove: pick('lastMove').asUciMoveOrNull(),
     clock: pick('clock').letOrNull(_clockDataFromPick),
     opening: pick('opening').letOrNull(_openingFromPick),
+    bookmarked: withBookmarked ? pick('bookmarked').asBoolOrFalse() : null,
   );
 }
 

lib/src/model/game/game_history.dart

@@ -38,7 +38,9 @@ Future<IList<LightArchivedGameWithPov>> myRecentGames(Ref ref) async {
   final session = ref.watch(authSessionProvider);
   if (session != null && online) {
     return ref.withClient(
-      (client) => GameRepository(client).getUserGames(session.user.id, max: kNumberOfRecentGames),
+      (client) => GameRepository(
+        client,
+      ).getUserGames(session.user.id, max: kNumberOfRecentGames, withBookmarked: true),
     );
   } else {
     final storage = await ref.watch(gameStorageProvider.future);
@@ -58,7 +60,9 @@ Future<IList<LightArchivedGameWithPov>> myRecentGames(Ref ref) async {
 /// A provider that fetches the recent games from the server for a given user.
 @riverpod
 Future<IList<LightArchivedGameWithPov>> userRecentGames(Ref ref, {required UserId userId}) {
-  return ref.withClient((client) => GameRepository(client).getUserGames(userId));
+  return ref.withClient(
+    (client) => GameRepository(client).getUserGames(userId, withBookmarked: true),
+  );
 }
 
 /// A provider that fetches the total number of games played by given user, or the current app user if no user is provided.
@@ -110,7 +114,10 @@ class UserGameHistory extends _$UserGameHistory {
     final id = userId ?? session?.user.id;
     final recentGames =
         id != null && online
-            ? ref.withClient((client) => GameRepository(client).getUserGames(id, filter: filter))
+            ? ref.withClient(
+              (client) =>
+                  GameRepository(client).getUserGames(id, filter: filter, withBookmarked: true),
+            )
             : storage
                 .page(userId: id, filter: filter)
                 .then(
@@ -149,6 +156,7 @@ class UserGameHistory extends _$UserGameHistory {
               max: _nbPerPage,
               until: _list.last.game.createdAt,
               filter: currentVal.filter,
+              withBookmarked: true,
             ),
           )
           : currentVal.online && currentVal.session != null
@@ -158,6 +166,7 @@ class UserGameHistory extends _$UserGameHistory {
               max: _nbPerPage,
               until: _list.last.game.createdAt,
               filter: currentVal.filter,
+              withBookmarked: true,
             ),
           )
           : (await ref.watch(gameStorageProvider.future))
@@ -192,6 +201,23 @@ class UserGameHistory extends _$UserGameHistory {
       },
     );
   }
+
+  void toggleBookmark(int index) {
+    if (!state.hasValue) return;
+
+    final gameList = state.requireValue.gameList;
+    final game = gameList[index].game;
+    final pov = gameList[index].pov;
+
+    state = AsyncData(
+      state.requireValue.copyWith(
+        gameList: gameList.replace(index, (
+          game: game.copyWith(bookmarked: !game.bookmarked!),
+          pov: pov,
+        )),
+      ),
+    );
+  }
 }
 
 @freezed

lib/src/model/game/game_repository.dart

@@ -13,11 +13,18 @@ class GameRepository {
 
   final LichessClient client;
 
-  Future<ArchivedGame> getGame(GameId id) {
+  Future<ArchivedGame> getGame(GameId id, {bool withBookmarked = false}) {
     return client.readJson(
-      Uri(path: '/game/export/$id', queryParameters: {'clocks': '1', 'accuracy': '1'}),
+      Uri(
+        path: '/game/export/$id',
+        queryParameters: {
+          'clocks': '1',
+          'accuracy': '1',
+          if (withBookmarked) 'withBookmarked': '1',
+        },
+      ),
       headers: {'Accept': 'application/json'},
-      mapper: ArchivedGame.fromServerJson,
+      mapper: (json) => ArchivedGame.fromServerJson(json, withBookmarked: withBookmarked),
     );
   }
 
@@ -34,6 +41,7 @@ class GameRepository {
     int max = 20,
     DateTime? until,
     GameFilterState filter = const GameFilterState(),
+    bool withBookmarked = false,
   }) {
     assert(!filter.perfs.contains(Perf.fromPosition));
     assert(!filter.perfs.contains(Perf.puzzle));
@@ -53,10 +61,11 @@ class GameRepository {
               if (filter.perfs.isNotEmpty)
                 'perfType': filter.perfs.map((perf) => perf.name).join(','),
               if (filter.side != null) 'color': filter.side!.name,
+              if (withBookmarked) 'withBookmarked': 'true',
             },
           ),
           headers: {'Accept': 'application/x-ndjson'},
-          mapper: LightArchivedGame.fromServerJson,
+          mapper: (json) => LightArchivedGame.fromServerJson(json, withBookmarked: withBookmarked),
         )
         .then(
           (value) =>
@@ -91,4 +100,13 @@ class GameRepository {
       mapper: LightArchivedGame.fromServerJson,
     );
   }
+
+  /// Bookmark the game for the given `id` if `bookmark` is true else unbookmark it
+  Future<void> bookmark(GameId id, {required bool bookmark}) async {
+    final uri = Uri(path: '/bookmark/$id', queryParameters: {'v': bookmark ? '1' : '0'});
+    final response = await client.post(uri);
+    if (response.statusCode >= 400) {
+      throw http.ClientException('Failed to bookmark game: ${response.statusCode}', uri);
+    }
+  }
 }

lib/src/model/game/game_repository_providers.dart

@@ -1,5 +1,6 @@
 import 'package:fast_immutable_collections/fast_immutable_collections.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:lichess_mobile/src/model/auth/auth_session.dart';
 import 'package:lichess_mobile/src/model/common/id.dart';
 import 'package:lichess_mobile/src/model/game/archived_game.dart';
 import 'package:lichess_mobile/src/model/game/game_repository.dart';
@@ -14,7 +15,10 @@ part 'game_repository_providers.g.dart';
 Future<ArchivedGame> archivedGame(Ref ref, {required GameId id}) async {
   ArchivedGame game;
   try {
-    game = await ref.withClient((client) => GameRepository(client).getGame(id));
+    final isLoggedIn = ref.watch(isLoggedInProvider);
+    game = await ref.withClient(
+      (client) => GameRepository(client).getGame(id, withBookmarked: isLoggedIn),
+    );
   } catch (_) {
     final gameStorage = await ref.watch(gameStorageProvider.future);
     final storedGame = await gameStorage.fetch(gameId: id);

lib/src/view/game/archived_game_screen.dart

@@ -4,6 +4,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:intl/intl.dart';
 import 'package:lichess_mobile/src/model/analysis/analysis_controller.dart';
+import 'package:lichess_mobile/src/model/auth/auth_session.dart';
 import 'package:lichess_mobile/src/model/common/id.dart';
 import 'package:lichess_mobile/src/model/game/archived_game.dart';
 import 'package:lichess_mobile/src/model/game/game.dart';
@@ -89,7 +90,7 @@ class _LoadGame extends ConsumerWidget {
   }
 }
 
-class _Body extends StatelessWidget {
+class _Body extends ConsumerWidget {
   const _Body({required this.gameData, required this.orientation, this.initialCursor, this.error});
 
   final LightArchivedGame? gameData;
@@ -98,13 +99,18 @@ class _Body extends StatelessWidget {
   final int? initialCursor;
 
   @override
-  Widget build(BuildContext context) {
+  Widget build(BuildContext context, WidgetRef ref) {
+    final isLoggedIn = ref.watch(isLoggedInProvider);
+
     return PlatformBoardThemeScaffold(
       appBar: PlatformAppBar(
         title: gameData != null ? _GameTitle(gameData: gameData!) : const SizedBox.shrink(),
         actions: [
           if (gameData == null && error == null) const PlatformAppBarLoadingIndicator(),
-          const ToggleSoundButton(),
+          if (gameData != null && isLoggedIn)
+            _GameMenu(id: gameData!.id, bookmarked: gameData!.bookmarked!)
+          else
+            const ToggleSoundButton(),
         ],
       ),
       body: SafeArea(
@@ -153,6 +159,35 @@ class _GameTitle extends StatelessWidget {
   }
 }
 
+class _GameMenu extends ConsumerWidget {
+  const _GameMenu({required this.id, required this.bookmarked});
+
+  final GameId id;
+  final bool bookmarked;
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    return PlatformContextMenuAnchor(
+      builder:
+          (context, controller, _) => AppBarIconButton(
+            icon: const Icon(Icons.more_horiz),
+            onPressed: () {
+              if (controller.isOpen) {
+                controller.close();
+              } else {
+                controller.open();
+              }
+            },
+            semanticsLabel: 'Game menu',
+          ),
+      actions: [
+        toggleSoundMenuAction(context, ref),
+        toggleBookmarkMenuAction(context, ref, id: id.gameId, bookmarked: bookmarked),
+      ],
+    );
+  }
+}
+
 class _BoardBody extends ConsumerWidget {
   const _BoardBody({
     required this.archivedGameData,