Merge branch 'master' into copy-pgn

app/controllers/Challenge.scala

@@ -279,51 +279,53 @@ final class Challenge(env: Env) extends LilaController(env):
 
   def apiCreate(username: UserStr) =
     ScopedBody(_.Challenge.Write, _.Bot.Play, _.Board.Play, _.Web.Mobile) { ctx ?=> me ?=>
-      (!me
-        .is(username))
-        .so(
-          bindForm(env.setup.forms.api.user)(
-            doubleJsonFormError,
-            config =>
-              limit.challenge(req.ipAddress, rateLimited, cost = if me.isApiHog then 0 else 1):
-                env.user.repo.enabledById(username).flatMap {
-                  case None => JsonBadRequest(jsonError(s"No such user: $username"))
-                  case Some(destUser) if destUser.isBot && !config.rules.isEmpty =>
-                    JsonBadRequest(jsonError("Rules not applicable for bots"))
-                  case Some(destUser) =>
-                    val cost = if me.isApiHog then 0 else if destUser.isBot then 1 else 5
-                    limit.challengeBot(req.ipAddress, rateLimited, cost = if me.isBot then 1 else 0):
-                      limit.challengeUser(me, rateLimited, cost = cost):
-                        for
-                          challenge <- makeOauthChallenge(config, me, destUser)
-                          grant     <- env.challenge.granter.isDenied(destUser, config.perfKey.some)
-                          res <- grant match
-                            case Some(denied) =>
-                              fuccess:
-                                JsonBadRequest:
-                                  jsonError(lila.challenge.ChallengeDenied.translated(denied))
-                            case _ =>
-                              env.challenge.api.create(challenge).flatMap {
-                                if _ then
-                                  ctx.isMobileOauth
-                                    .so(env.challenge.version(challenge.id).dmap(some))
-                                    .map: socketVersion =>
-                                      val json = env.challenge.jsonView
-                                        .apiAndMobile(
-                                          challenge,
-                                          socketVersion,
-                                          lila.challenge.Direction.Out.some
-                                        )
-                                      if config.keepAliveStream then
-                                        jsOptToNdJson:
-                                          ndJson.addKeepAlive(env.challenge.keepAliveStream(challenge, json))
-                                      else JsonOk(json)
-                                else JsonBadRequest(jsonError("Challenge not created")).toFuccess
-                              }
-                        yield res
-                }
-          )
+      (!me.is(username)).so(
+        bindForm(env.setup.forms.api.user)(
+          doubleJsonFormError,
+          config =>
+            limit.challenge(req.ipAddress, rateLimited, cost = if me.isApiHog then 0 else 1):
+              env.user.repo.enabledById(username).flatMap {
+                case None => JsonBadRequest(jsonError(s"No such user: $username"))
+                case Some(destUser) if destUser.isBot && !config.rules.isEmpty =>
+                  JsonBadRequest(jsonError("Rules not applicable for bots"))
+                case Some(destUser) =>
+                  env.relation.api
+                    .fetchFollows(destUser.id, me.id)
+                    .flatMap: isFriend =>
+                      val cost = if isFriend || me.isApiHog then 0 else if destUser.isBot then 1 else 5
+                      limit.challengeBot(req.ipAddress, rateLimited, cost = if me.isBot then 1 else 0):
+                        limit.challengeUser(me, rateLimited, cost = cost):
+                          for
+                            challenge <- makeOauthChallenge(config, me, destUser)
+                            grant     <- env.challenge.granter.isDenied(destUser, config.perfKey.some)
+                            res <- grant match
+                              case Some(denied) =>
+                                fuccess:
+                                  JsonBadRequest:
+                                    jsonError(lila.challenge.ChallengeDenied.translated(denied))
+                              case _ =>
+                                env.challenge.api.create(challenge).flatMap {
+                                  if _ then
+                                    ctx.isMobileOauth
+                                      .so(env.challenge.version(challenge.id).dmap(some))
+                                      .map: socketVersion =>
+                                        val json = env.challenge.jsonView
+                                          .apiAndMobile(
+                                            challenge,
+                                            socketVersion,
+                                            lila.challenge.Direction.Out.some
+                                          )
+                                        if config.keepAliveStream then
+                                          jsOptToNdJson:
+                                            ndJson
+                                              .addKeepAlive(env.challenge.keepAliveStream(challenge, json))
+                                        else JsonOk(json)
+                                  else JsonBadRequest(jsonError("Challenge not created")).toFuccess
+                                }
+                          yield res
+              }
         )
+      )
     }
 
   private def makeOauthChallenge(config: ApiConfig, orig: lila.user.User, dest: lila.user.User) =

app/views/analyse/replayBot.scala

@@ -13,11 +13,11 @@ def replayBot(
     .css("analyse.round")
     .graph(views.round.ui.povOpenGraph(pov))
     .csp(bits.csp)
-    .robots(false):
+    .flag(_.noRobots):
       main(cls := "analyse")(
-        st.aside(cls := "analyse__side")(
+        st.aside(cls := "analyse__side"):
           views.game.side(pov, initialFen, none, simul = simul, bookmarked = false)
-        ),
+        ,
         div(cls := "analyse__board main-board")(chessgroundBoard),
         div(cls := "analyse__tools")(div(cls := "ceval")),
         div(cls := "analyse__controls"),
@@ -31,9 +31,8 @@ def replayBot(
               div(cls := "pgn")(pgn)
             ),
             cross.map: c =>
-              div(cls := "ctable active")(
+              div(cls := "ctable active"):
                 views.game.ui.crosstable(pov.player.userId.fold(c)(c.fromPov), pov.gameId.some)
-              )
           )
         )
       )

app/views/analyse/ui.scala

@@ -12,7 +12,7 @@ object bits:
   val dataPanel = attr("data-panel")
 
   def page(title: String)(using Context): Page =
-    Page(title).zoom.robots(false).csp(csp)
+    Page(title).flag(_.zoom).flag(_.noRobots).csp(csp)
 
   def csp(using Context): Update[lila.ui.ContentSecurityPolicy] =
     ui.csp.compose(_.withPeer.withInlineIconFont.withChessDbCn)

app/views/base/page.scala

@@ -3,7 +3,7 @@ import scalalib.StringUtils.escapeHtmlRaw
 
 import lila.app.UiEnv.{ *, given }
 import lila.common.String.html.safeJsonValue
-import lila.ui.RenderedPage
+import lila.ui.{ RenderedPage, PageFlags }
 
 object page:
 
@@ -42,6 +42,8 @@ object page:
     val allModules = p.modules ++
       p.pageModule.so(module => esmPage(module.name)) ++
       ctx.needsFp.so(fingerprintTag)
+    val zenable = p.flags(PageFlags.zen)
+    val playing = p.flags(PageFlags.playing)
     val pageFrag = frag(
       doctype,
       htmlTag(
@@ -73,7 +75,7 @@ object page:
           ),
           link(rel := "mask-icon", href := staticAssetUrl("logo/lichess.svg"), attr("color") := "black"),
           favicons,
-          (!p.robots || !netConfig.crawlable).option:
+          (p.flags(PageFlags.noRobots) || !netConfig.crawlable).option:
             raw("""<meta content="noindex, nofollow" name="robots">""")
           ,
           noTranslate,
@@ -101,12 +103,12 @@ object page:
               "blind-mode"           -> ctx.blind,
               "kid"                  -> ctx.kid.yes,
               "mobile"               -> lila.common.HTTPRequest.isMobileBrowser(ctx.req),
-              "playing fixed-scroll" -> p.playing,
-              "no-rating"            -> (!pref.showRatings || (p.playing && pref.hideRatingsInGame)),
+              "playing fixed-scroll" -> playing,
+              "no-rating"            -> (!pref.showRatings || (playing && pref.hideRatingsInGame)),
               "no-flair"             -> !pref.flairs,
-              "zen"                  -> (pref.isZen || (p.playing && pref.isZenAuto)),
-              "zenable"              -> p.zenable,
-              "zen-auto"             -> (p.zenable && pref.isZenAuto)
+              "zen"                  -> (pref.isZen || (playing && pref.isZenAuto)),
+              "zenable"              -> zenable,
+              "zen-auto"             -> (zenable && pref.isZenAuto)
             )
           },
           dataDev,
@@ -126,7 +128,7 @@ object page:
           dataBoard3d      := pref.currentTheme3d.name,
           dataPieceSet3d   := pref.currentPieceSet3d.name,
           dataAnnounce     := lila.web.AnnounceApi.get.map(a => safeJsonValue(a.json)),
-          style            := boardStyle(p.zoomable)
+          style            := boardStyle(p.flags(PageFlags.zoom))
         )(
           blindModeForm,
           ctx.data.inquiry.map { views.mod.inquiry(_) },
@@ -136,9 +138,9 @@ object page:
             .get(ctx.req)
             .ifTrue(ctx.isAnon)
             .map(u => views.auth.checkYourEmailBanner(u.username, u.email)),
-          p.zenable.option(zenZone),
+          zenable.option(zenZone),
           ui.siteHeader(
-            zenable = p.zenable,
+            zenable = zenable,
             isAppealUser = ctx.isAppealUser,
             challenges = ctx.nbChallenges,
             notifications = ctx.nbNotifications.value,
@@ -151,7 +153,7 @@ object page:
           div(
             id := "main-wrap",
             cls := List(
-              "full-screen-force" -> p.fullScreenClass,
+              "full-screen-force" -> p.flags(PageFlags.fullScreen),
               "is2d"              -> pref.is2d,
               "is3d"              -> pref.is3d
             )

app/views/round/player.scala

@@ -44,7 +44,7 @@ def player(
   val opponentNameOrZen = if ctx.pref.isZen || ctx.pref.isZenAuto then "ZEN" else playerText(pov.opponent)
   ui.RoundPage(pov.game.variant, s"${trans.site.play.txt()} $opponentNameOrZen")
     .js(roundNvuiTag)
-    .js(
+    .js:
       PageModule(
         "round",
         Json
@@ -55,10 +55,9 @@ def player(
           )
           .add("noab" -> ctx.me.exists(_.marks.engine))
       )
-    )
     .graph(ui.povOpenGraph(pov))
-    .zen
-    .copy(playing = pov.game.playable):
+    .flag(_.zen)
+    .flag(_.playing, pov.game.playable):
       main(cls := "round")(
         st.aside(cls := "round__side")(
           side(pov, data, tour.map(_.tourAndTeamVs), simul, bookmarked = bookmarked),

app/views/round/watcher.scala

@@ -40,7 +40,7 @@ def watcher(
       )
     )
     .graph(ui.povOpenGraph(pov))
-    .zen:
+    .flag(_.zen):
       main(cls := "round")(
         st.aside(cls := "round__side")(
           side(pov, data, tour, simul, userTv, bookmarked),

app/views/study.scala

@@ -80,8 +80,8 @@ def show(
         ) ++ views.board.explorerAndCevalConfig
       )
     )
-    .robots(s.isPublic)
-    .zoom
+    .flag(_.noRobots, !s.isPublic)
+    .flag(_.zoom)
     .csp(views.analyse.ui.csp.compose(_.withPeer.withExternalAnalysisApis))
     .graph(
       title = s.name.value,

app/views/team/show.scala

@@ -49,7 +49,7 @@ object show:
               ))
         )
       )
-      .robots(t.team.enabled):
+      .flag(_.noRobots, !t.team.enabled):
         val canManage     = asMod && isGranted(_.ManageTeam)
         val canSeeMembers = canManage || (t.enabled && (t.publicMembers || info.mine))
         main(

app/views/team/tournaments.scala

@@ -14,7 +14,7 @@ object tournaments:
         description = shorten(t.description.value, 152)
       )
       .css("bits.team")
-      .fullScreen:
+      .flag(_.fullScreen):
         main(
           div(cls := "box")(
             boxTop:

app/views/tv.scala

@@ -26,7 +26,7 @@ def index(
         s"Sit back, relax, and watch the best ${channel.name.toLowerCase} Lichess players compete on Lichess TV",
       url = s"$netBaseUrl${routes.Tv.onChannel(channel.key)}"
     )
-    .zen
+    .flag(_.zen)
     .hrefLangs(lila.ui.LangPath(routes.Tv.index)):
       main(cls := "round tv-single")(
         st.aside(cls := "round__side")(

app/views/user/show/page.scala

@@ -15,6 +15,8 @@ object page:
 
   lazy val side = lila.user.ui.UserShowSide(helpers)
 
+  private def indexable(u: User) = u.isVerified || u.count.game >= 10
+
   def activity(
       activities: Seq[lila.activity.ActivityView],
       info: UserInfo,
@@ -34,7 +36,7 @@ object page:
       .js(esModules())
       .css("bits.user.show")
       .css(isGranted(_.UserModView).option("mod.user"))
-      .robots(u.count.game >= 10):
+      .flag(_.noRobots, !indexable(u)):
         main(cls := "page-menu", ui.dataUsername := u.username)(
           st.aside(cls := "page-menu__menu")(side(u, info.ranks, none)),
           div(cls := "page-menu__content box user-show")(
@@ -60,7 +62,7 @@ object page:
       .css("bits.user.show")
       .css((filters.current.name == "search").option("bits.user.show.search"))
       .css(isGranted(_.UserModView).option("mod.user"))
-      .robots(u.count.game >= 10):
+      .flag(_.noRobots, !indexable(u)):
         main(cls := "page-menu", ui.dataUsername := u.username)(
           st.aside(cls := "page-menu__menu")(side(u, info.ranks, none)),
           div(cls := "page-menu__content box user-show")(

modules/analyse/src/main/ui/AnalyseUi.scala

@@ -30,7 +30,7 @@ final class AnalyseUi(helpers: Helpers)(externalEngineEndpoint: String):
         url = s"$netBaseUrl${routes.UserAnalysis.index.url}",
         description = "Analyse chess positions and variations on an interactive chess board"
       )
-      .zoom:
+      .flag(_.zoom):
         main(
           cls := List(
             "analyse"       -> true,