add ?withBookmarked flag to /api/games/user for #15773

Author: ornicar

app/Env.scala

@@ -51,8 +51,8 @@ final class Env(
   val analyse: lila.analyse.Env         = wire[lila.analyse.Env]
   val fishnet: lila.fishnet.Env         = wire[lila.fishnet.Env]
   val history: lila.history.Env         = wire[lila.history.Env]
-  val round: lila.round.Env             = wire[lila.round.Env]
   val bookmark: lila.bookmark.Env       = wire[lila.bookmark.Env]
+  val round: lila.round.Env             = wire[lila.round.Env]
   val search: lila.search.Env           = wire[lila.search.Env]
   val gameSearch: lila.gameSearch.Env   = wire[lila.gameSearch.Env]
   val perfStat: lila.perfStat.Env       = wire[lila.perfStat.Env]

app/controllers/Game.scala

@@ -12,7 +12,9 @@ import lila.core.id.GameAnyId
 final class Game(env: Env, apiC: => Api) extends LilaController(env):
 
   def bookmark(gameId: GameId) = AuthOrScopedBody(_.Web.Mobile) { _ ?=> me ?=>
-    env.bookmark.api.toggle(gameId, me, getBoolOpt("v")).inject(NoContent)
+    env.bookmark.api
+      .toggle(env.round.gameProxy.updateIfPresent)(gameId, me, getBoolOpt("v"))
+      .inject(NoContent)
   }
 
   def delete(gameId: GameId) = Auth { _ ?=> me ?=>
@@ -146,7 +148,8 @@ final class Game(env: Env, apiC: => Api) extends LilaController(env):
       delayMoves = delayMovesFromReq,
       lastFen = getBool("lastFen"),
       accuracy = getBool("accuracy"),
-      division = getBoolOpt("division") | extended
+      division = getBoolOpt("division") | extended,
+      bookmark = getBool("withBookmarked")
     )
 
   private[controllers] def delayMovesFromReq(using RequestHeader) =

modules/api/src/main/Env.scala

@@ -60,6 +60,7 @@ final class Env(
     cacheApi: lila.memo.CacheApi,
     webConfig: lila.web.WebConfig,
     realPlayerApi: lila.web.RealPlayerApi,
+    bookmarkExists: lila.core.bookmark.BookmarkExists,
     manifest: lila.web.AssetManifest
 )(using val mode: Mode, scheduler: Scheduler)(using
     Executor,

modules/api/src/main/GameApiV2.scala

@@ -32,7 +32,8 @@ final class GameApiV2(
     getLightUser: LightUser.Getter,
     realPlayerApi: RealPlayerApi,
     gameProxy: GameProxyRepo,
-    division: Divider
+    division: Divider,
+    bookmarkExists: lila.core.bookmark.BookmarkExists
 )(using Executor, akka.actor.ActorSystem):
 
   import GameApiV2.*
@@ -278,6 +279,7 @@ final class GameApiV2(
           .apply(g, initialFen, analysisOption, config.flags, realPlayers = realPlayers)
           .dmap(annotator.toPgnString)
       )
+    bookmarked <- config.flags.bookmark.so(bookmarkExists(g, config.by.map(_.userId)))
     accuracy = analysisOption
       .ifTrue(flags.accuracy)
       .flatMap:
@@ -325,6 +327,7 @@ final class GameApiV2(
     .add("lastFen" -> flags.lastFen.option(Fen.write(g.chess.situation)))
     .add("lastMove" -> flags.lastFen.option(g.lastMoveKeys))
     .add("division" -> flags.division.option(division(g, initialFen)))
+    .add("bookmarked" -> bookmarked)
 
   private def gameLightUsers(game: Game): Future[ByColor[(lila.core.game.Player, Option[LightUser])]] =
     game.players.traverse(_.userId.so(getLightUser)).dmap(game.players.zip(_))

modules/bookmark/src/main/BookmarkApi.scala

@@ -7,12 +7,7 @@ import lila.db.dsl.{ *, given }
 
 case class Bookmark(game: Game, user: User)
 
-final class BookmarkApi(
-    coll: Coll,
-    gameApi: GameApi,
-    gameProxy: lila.core.game.GameProxy,
-    paginator: PaginatorBuilder
-)(using Executor):
+final class BookmarkApi(coll: Coll, gameApi: GameApi, paginator: PaginatorBuilder)(using Executor):
 
   private def exists(gameId: GameId, userId: UserId): Fu[Boolean] =
     coll.exists(selectId(gameId, userId))
@@ -38,7 +33,9 @@ final class BookmarkApi(
 
   def remove(gameId: GameId, userId: UserId): Funit = coll.delete.one(selectId(gameId, userId)).void
 
-  def toggle(gameId: GameId, userId: UserId, v: Option[Boolean]): Funit =
+  def toggle(
+      updateProxy: GameId => Update[Game] => Funit
+  )(gameId: GameId, userId: UserId, v: Option[Boolean]): Funit =
     exists(gameId, userId)
       .flatMap: e =>
         val newValue = v.getOrElse(!e)
@@ -48,7 +45,7 @@ final class BookmarkApi(
             _ <- if newValue then add(gameId, userId, nowInstant) else remove(gameId, userId)
             inc = if newValue then 1 else -1
             _ <- gameApi.incBookmarks(gameId, inc)
-            _ <- gameProxy.updateIfPresent(gameId)(g => g.copy(bookmarks = g.bookmarks + inc))
+            _ <- updateProxy(gameId)(g => g.copy(bookmarks = g.bookmarks + inc))
           yield ()
       .recover:
         lila.db.ignoreDuplicateKey

modules/bookmark/src/main/Env.scala

@@ -8,8 +8,7 @@ import lila.core.config.*
 final class Env(
     db: lila.db.Db,
     gameApi: lila.core.game.GameApi,
-    gameRepo: lila.core.game.GameRepo,
-    gameProxyRepo: lila.core.game.GameProxy
+    gameRepo: lila.core.game.GameRepo
 )(using Executor):
 
   private lazy val bookmarkColl = db(CollName("bookmark"))

modules/core/src/main/game/misc.scala

@@ -123,7 +123,7 @@ abstract class GameRepo(val coll: BSONCollection):
   def sortedCursor(user: UserId, pk: PerfKey): AkkaStreamCursor[Game]
 
 trait GameProxy:
-  def updateIfPresent(gameId: GameId)(f: Game => Game): Funit
+  def updateIfPresent(gameId: GameId)(f: Update[Game]): Funit
   def game(gameId: GameId): Fu[Option[Game]]
   def upgradeIfPresent(games: List[Game]): Fu[List[Game]]
   def flushIfPresent(gameId: GameId): Funit
@@ -177,7 +177,8 @@ object PgnDump:
       delayMoves: Boolean = false,
       lastFen: Boolean = false,
       accuracy: Boolean = false,
-      division: Boolean = false
+      division: Boolean = false,
+      bookmark: Boolean = false
   ):
     def requiresAnalysis           = evals || accuracy
     def keepDelayIf(cond: Boolean) = copy(delayMoves = delayMoves && cond)