/api/user?challenge=true

app/controllers/Account.scala

@@ -102,6 +102,7 @@ final class Account(
  me.value,
  withFollows = apiC.userWithFollows,
  withTrophies = false,
+ withCanChallenge = false,
  forWiki = wikiGranted
  )
  .dmap { JsonOk(_) }

app/controllers/Api.scala

@@ -47,7 +47,8 @@ final class Api(
  .extended(
  name,
  withFollows = userWithFollows,
- withTrophies = getBool("trophies")
+ withTrophies = getBool("trophies"),
+ withCanChallenge = getBool("challenge")
  )
  .map(toApiResult)
  .map(toHttp)

app/controllers/Challenge.scala

@@ -274,7 +274,7 @@ final class Challenge(
  case None => redir
  case Some(dest) if ctx.is(dest) => redir
  case Some(dest) =>
- env.challenge.granter.isDenied(dest, c.perfType).flatMap {
+ env.challenge.granter.isDenied(dest, c.perfType.key.some).flatMap {
  case Some(denied) =>
  showChallenge(c, lila.challenge.ChallengeDenied.translated(denied).some)
  case None => api.setDestUser(c, dest).inject(redir)
@@ -303,7 +303,7 @@ final class Challenge(
  limit.challengeUser(me, rateLimited, cost = cost):
  for
  challenge <- makeOauthChallenge(config, me, destUser)
- grant <- env.challenge.granter.isDenied(destUser, config.perfType)
+ grant <- env.challenge.granter.isDenied(destUser, config.perfKey.some)
  res <- grant match
  case Some(denied) =>
  fuccess:
@@ -376,7 +376,7 @@ final class Challenge(
  NoBot:
  Found(env.game.gameRepo.game(gameId)): g =>
  g.opponentOf(me).flatMap(_.userId).so(env.user.repo.byId).orNotFound { opponent =>
- env.challenge.granter.isDenied(opponent, g.perfKey).flatMap {
+ env.challenge.granter.isDenied(opponent, g.perfKey.some).flatMap {
  case Some(d) => BadRequest(jsonError(lila.challenge.ChallengeDenied.translated(d)))
  case _ =>
  api.offerRematchForGame(g, me).map {

app/controllers/Setup.scala

@@ -48,7 +48,7 @@ final class Setup(
  for
  origUser <- ctx.user.soFu(env.user.perfsRepo.withPerf(_, config.perfType))
  destUser <- userId.so(env.user.api.enabledWithPerf(_, config.perfType))
- denied <- destUser.so(u => env.challenge.granter.isDenied(u.user, config.perfType))
+ denied <- destUser.so(u => env.challenge.granter.isDenied(u.user, config.perfKey.some))
  result <- denied match
  case Some(denied) =>
  val message = lila.challenge.ChallengeDenied.translated(denied)

modules/api/src/main/UserApi.scala

@@ -27,6 +27,7 @@ final class UserApi(
  trophyApi: lila.user.TrophyApi,
  shieldApi: lila.tournament.TournamentShieldApi,
  revolutionApi: lila.tournament.RevolutionApi,
+ challengeGranter: lila.challenge.ChallengeGranter,
  net: NetConfig
 )(using Executor, lila.core.i18n.Translator):
 
@@ -38,16 +39,18 @@ final class UserApi(
  def extended(
  username: UserStr,
  withFollows: Boolean,
- withTrophies: Boolean
+ withTrophies: Boolean,
+ withCanChallenge: Boolean
  )(using Option[Me], Lang): Fu[Option[JsObject]] =
  userApi.withPerfs(username).flatMapz {
- extended(_, withFollows, withTrophies).dmap(some)
+ extended(_, withFollows, withTrophies, withCanChallenge).dmap(some)
  }
 
  def extended(
  u: User | UserWithPerfs,
  withFollows: Boolean,
  withTrophies: Boolean,
+ withCanChallenge: Boolean,
  forWiki: Boolean = false
  )(using as: Option[Me], lang: Lang): Fu[JsObject] =
  u.match
@@ -69,6 +72,7 @@ final class UserApi(
  gameCache.nbImportedBy(u.id),
  (withTrophies && !u.lame).soFu(getTrophiesAndAwards(u.user)),
  streamerApi.listed(u.user),
+ withCanChallenge.so(challengeGranter.mayChallenge(u.user).dmap(some)),
  forWiki.soFu(userRepo.email(u.id))
  ).mapN:
  (
@@ -83,6 +87,7 @@ final class UserApi(
  nbImported,
  trophiesAndAwards,
  streamer,
+ canChallenge,
  email
  ) =>
  jsonView.full(u.user, u.perfs.some, withProfile = true) ++ {
@@ -112,6 +117,7 @@ final class UserApi(
  .add("nbFollowing", following)
  .add("nbFollowers", withFollows.option(0))
  .add("trophies", trophiesAndAwards.map(trophiesJson))
+ .add("canChallenge", canChallenge)
  .add(
  "streamer",
  streamer.map: s =>

modules/challenge/src/main/ChallengeGranter.scala

@@ -42,38 +42,42 @@ final class ChallengeGranter(
 
  val ratingThreshold = 300
 
- def isDenied(dest: User, perfKey: PerfKey)(using
+ def mayChallenge(dest: User)(using Executor)(using me: Option[Me]): Fu[Boolean] =
+ isDenied(dest, None).map(_.isEmpty)
+
+ // perfkey is None when we're not yet trying to challenge
+ def isDenied(dest: User, perfKey: Option[PerfKey])(using
  Executor
  )(using me: Option[Me]): Fu[Option[ChallengeDenied]] = me
- .fold[Fu[Option[ChallengeDenied.Reason]]] {
- prefApi.getChallenge(dest.id).map {
- case lila.core.pref.Challenge.ALWAYS => none
- case _ => YouAreAnon.some
- }
- } { from =>
- type Res = Option[ChallengeDenied.Reason]
- given Conversion[Res, Fu[Res]] = fuccess
- relationApi.fetchRelation(dest.id, from.userId).zip(prefApi.getChallenge(dest.id)).flatMap {
- case (Some(Block), _) => YouAreBlocked.some
- case (_, lila.core.pref.Challenge.NEVER) => TheyDontAcceptChallenges.some
- case (Some(Follow), _)  => none // always accept from followed
- case (_, _) if from.marks.engine && !dest.marks.engine => YouAreBlocked.some
- case (_, lila.core.pref.Challenge.FRIEND) => FriendsOnly.some
- case (_, lila.core.pref.Challenge.RATING) =>
- userApi
- .perfsOf(from.value -> dest, primary = false)
- .map: (fromPerfs, destPerfs) =>
- if fromPerfs(perfKey).provisional || destPerfs(perfKey).provisional
- then RatingIsProvisional(perfKey).some
- else
- val diff =
- math.abs(fromPerfs(perfKey).intRating.value - destPerfs(perfKey).intRating.value)
- (diff > ratingThreshold).option(RatingOutsideRange(perfKey))
- case (_, lila.core.pref.Challenge.REGISTERED) => none
- case _ if from == dest => SelfChallenge.some
- case _    => none
- }
- }
+ .match
+ case None =>
+ prefApi.getChallenge(dest.id).map {
+  case lila.core.pref.Challenge.ALWAYS => none
+  case _ => YouAreAnon.some
+  }
+ case Some(from) =>
+  type Res = Option[ChallengeDenied.Reason]
+  given Conversion[Res, Fu[Res]] = fuccess
+ relationApi.fetchRelation(dest.id, from.userId).zip(prefApi.getChallenge(dest.id)).flatMap {
+  case (Some(Block), _)  => YouAreBlocked.some
+  case (_, lila.core.pref.Challenge.NEVER) => TheyDontAcceptChallenges.some
+  case (Some(Follow), _)  => none // always accept from followed
+  case (_, _) if from.marks.engine && !dest.marks.engine => YouAreBlocked.some
+  case (_, lila.core.pref.Challenge.FRIEND) => FriendsOnly.some
+ case (_, lila.core.pref.Challenge.RATING) =>
+ perfKey.so: pk =>
+  userApi
+  .perfsOf(from.value -> dest, primary = false)
+  .map: (fromPerfs, destPerfs) =>
+  if fromPerfs(pk).provisional || destPerfs(pk).provisional
+  then RatingIsProvisional(pk).some
+ else
+  val diff = math.abs(fromPerfs(pk).intRating.value - destPerfs(pk).intRating.value)
+  (diff > ratingThreshold).option(RatingOutsideRange(pk))
+  case (_, lila.core.pref.Challenge.REGISTERED) => none
+  case _ if from == dest => SelfChallenge.some
+  case _ => none
+  }
  .map:
  case None if dest.isBot && perfKey == PerfKey.ultraBullet => BotUltraBullet.some
  case res => res

modules/setup/src/main/ApiConfig.scala

@@ -23,6 +23,7 @@ final case class ApiConfig(
 ):
 
  def perfType: PerfType = lila.rating.PerfType(variant, chess.Speed(days.isEmpty.so(clock)))
+ def perfKey = perfType.key
 
  def validFen = Variant.isValidInitialFen(variant, position)
 

modules/setup/src/main/Config.scala

@@ -58,6 +58,7 @@ private[setup] trait Config:
  def makeSpeed: Speed = chess.Speed(makeClock)
 
  def perfType: PerfType = lila.rating.PerfType(variant, makeSpeed)
+ def perfKey = perfType.key
 
 trait Positional:
  self: Config =>