lila/app/controllers/Api.scala

package controllers

import play.api.libs.json._
import play.api.mvc._
import scala.concurrent.duration._

import lila.api.Context
import lila.app._
import lila.common.{ HTTPRequest, IpAddress }

object Api extends LilaController {

  private val userApi = Env.api.userApi
  private val gameApi = Env.api.gameApi

  private implicit val limitedDefault = ornicar.scalalib.Zero.instance[ApiResult](Limited)

  private lazy val apiStatusResponse = {
    val api = lila.api.Mobile.Api
    Ok(Json.obj(
      "api" -> Json.obj(
        "current" -> api.currentVersion.value,
        "olds" -> api.oldVersions.map { old =>
          Json.obj(
            "version" -> old.version.value,
            "deprecatedAt" -> old.deprecatedAt,
            "unsupportedAt" -> old.unsupportedAt
          )
        }
      )
    )) as JSON
  }

  val status = Action { req =>
    apiStatusResponse
  }

  def user(name: String) = ApiRequest { implicit ctx =>
    userApi one name map toApiResult
  }

  private val UsersRateLimitGlobal = new lila.memo.RateLimit[String](
    credits = 1000,
    duration = 1 minute,
    name = "team users API global",
    key = "team_users.api.global"
  )

  private val UsersRateLimitPerIP = new lila.memo.RateLimit[IpAddress](
    credits = 1000,
    duration = 10 minutes,
    name = "team users API per IP",
    key = "team_users.api.ip"
  )

  def users = ApiRequest { implicit ctx =>
    val page = (getInt("page") | 1) atLeast 1 atMost 50
    val nb = (getInt("nb") | 10) atLeast 1 atMost 50
    val cost = page * nb + 10
    val ip = HTTPRequest lastRemoteAddress ctx.req
    UsersRateLimitPerIP(ip, cost = cost) {
      UsersRateLimitGlobal("-", cost = cost, msg = ip.value) {
        lila.mon.api.teamUsers.cost(cost)
        (get("team") ?? Env.team.api.team).flatMap {
          _ ?? { team =>
            Env.team.pager(team, page, nb) map userApi.pager map some
          }
        } map toApiResult
      }
    }
  }

  def usersByIds = OpenBody(parse.tolerantText) { implicit ctx =>
    val usernames = ctx.body.body.split(',').take(300).toList
    val ip = HTTPRequest lastRemoteAddress ctx.req
    val cost = usernames.size / 4
    UsersRateLimitPerIP(ip, cost = cost) {
      UsersRateLimitGlobal("-", cost = cost, msg = ip.value) {
        lila.mon.api.users.cost(1)
        lila.user.UserRepo nameds usernames map {
          _.map { Env.user.jsonView(_, none) }
        } map toApiResult map toHttp
      }
    }
  }

  def usersStatus = ApiRequest { implicit ctx =>
    val ids = get("ids").??(_.split(',').take(40).toList map lila.user.User.normalize)
    Env.user.lightUserApi asyncMany ids dmap (_.flatten) map { users =>
      val actualIds = users.map(_.id)
      val onlineIds = Env.user.onlineUserIdMemo intersect actualIds
      val playingIds = Env.relation.online.playing intersect actualIds
      toApiResult {
        users.map { u =>
          lila.common.LightUser.lightUserWrites.writes(u) ++ Json.obj(
            "online" -> onlineIds.contains(u.id),
            "playing" -> playingIds.contains(u.id)
          )
        }
      }
    }
  }

  private val UserGamesRateLimitPerIP = new lila.memo.RateLimit[IpAddress](
    credits = 10 * 1000,
    duration = 10 minutes,
    name = "user games API per IP",
    key = "user_games.api.ip"
  )

  private val UserGamesRateLimitPerUA = new lila.memo.RateLimit[String](
    credits = 10 * 1000,
    duration = 5 minutes,
    name = "user games API per UA",
    key = "user_games.api.ua"
  )

  private val UserGamesRateLimitGlobal = new lila.memo.RateLimit[String](
    credits = 15 * 1000,
    duration = 2 minute,
    name = "user games API global",
    key = "user_games.api.global"
  )

  def userGames(name: String) = ApiRequest { implicit ctx =>
    val page = (getInt("page") | 1) atLeast 1 atMost 200
    val nb = (getInt("nb") | 10) atLeast 1 atMost 100
    val cost = page * nb + 10
    val ip = HTTPRequest lastRemoteAddress ctx.req
    UserGamesRateLimitPerIP(ip, cost = cost) {
      UserGamesRateLimitPerUA(~HTTPRequest.userAgent(ctx.req), cost = cost, msg = ip.value) {
        UserGamesRateLimitGlobal("-", cost = cost, msg = ip.value) {
          lila.mon.api.userGames.cost(cost)
          lila.user.UserRepo named name flatMap {
            _ ?? { user =>
              gameApi.byUser(
                user = user,
                rated = getBoolOpt("rated"),
                playing = getBoolOpt("playing"),
                analysed = getBoolOpt("analysed"),
                withAnalysis = getBool("with_analysis"),
                withMoves = getBool("with_moves"),
                withOpening = getBool("with_opening"),
                withMoveTimes = getBool("with_movetimes"),
                token = get("token"),
                nb = nb,
                page = page
              ) map some
            }
          } map toApiResult
        }
      }
    }
  }

  private val GameRateLimitPerIP = new lila.memo.RateLimit[IpAddress](
    credits = 100,
    duration = 1 minute,
    name = "game API per IP",
    key = "game.api.one.ip"
  )

  def game(id: String) = ApiRequest { implicit ctx =>
    val ip = HTTPRequest lastRemoteAddress ctx.req
    GameRateLimitPerIP(ip, cost = 1) {
      lila.mon.api.game.cost(1)
      gameApi.one(
        id = id take lila.game.Game.gameIdSize,
        withAnalysis = getBool("with_analysis"),
        withMoves = getBool("with_moves"),
        withOpening = getBool("with_opening"),
        withFens = getBool("with_fens"),
        withMoveTimes = getBool("with_movetimes"),
        token = get("token")
      ) map toApiResult
    }
  }

  def games = OpenBody(parse.tolerantText) { implicit ctx =>
    val gameIds = ctx.body.body.split(',').take(300)
    val ip = HTTPRequest lastRemoteAddress ctx.req
    GameRateLimitPerIP(ip, cost = gameIds.size / 4) {
      lila.mon.api.game.cost(1)
      gameApi.many(
        ids = gameIds,
        withMoves = getBool("with_moves")
      ) map toApiResult map toHttp
    }
  }

  def gamesVs(u1: String, u2: String) = ApiRequest { implicit ctx =>
    val page = (getInt("page") | 1) atLeast 1 atMost 200
    val nb = (getInt("nb") | 10) atLeast 1 atMost 100
    val cost = page * nb * 2 + 10
    val ip = HTTPRequest lastRemoteAddress ctx.req
    UserGamesRateLimitPerIP(ip, cost = cost) {
      UserGamesRateLimitPerUA(~HTTPRequest.userAgent(ctx.req), cost = cost, msg = ip.value) {
        UserGamesRateLimitGlobal("-", cost = cost, msg = ip.value) {
          lila.mon.api.userGames.cost(cost)
          for {
            usersO <- lila.user.UserRepo.pair(
              lila.user.User.normalize(u1),
              lila.user.User.normalize(u2)
            )
            res <- usersO.?? { users =>
              gameApi.byUsersVs(
                users = users,
                rated = getBoolOpt("rated"),
                playing = getBoolOpt("playing"),
                analysed = getBoolOpt("analysed"),
                withAnalysis = getBool("with_analysis"),
                withMoves = getBool("with_moves"),
                withOpening = getBool("with_opening"),
                withMoveTimes = getBool("with_movetimes"),
                nb = nb,
                page = page
              ) map some
            }
          } yield toApiResult(res)
        }
      }
    }
  }

  def currentTournaments = ApiRequest { implicit ctx =>
    Env.tournament.api.fetchVisibleTournaments flatMap
      Env.tournament.scheduleJsonView.apply map Data.apply
  }

  def tournament(id: String) = ApiRequest { implicit ctx =>
    val page = (getInt("page") | 1) atLeast 1 atMost 200
    lila.tournament.TournamentRepo byId id flatMap {
      _ ?? { tour =>
        Env.tournament.jsonView(tour, page.some, none, none, none) map some
      }
    } map toApiResult
  }

  def gameStream = Action(parse.tolerantText) { req =>
    val userIds = req.body.split(',').take(300).toSet map lila.user.User.normalize
    Ok.chunked(Env.game.stream.startedByUserIds(userIds))
  }

  sealed trait ApiResult
  case class Data(json: JsValue) extends ApiResult
  case object NoData extends ApiResult
  case object Limited extends ApiResult
  def toApiResult(json: Option[JsValue]): ApiResult = json.fold[ApiResult](NoData)(Data.apply)
  def toApiResult(json: Seq[JsValue]): ApiResult = Data(JsArray(json))

  private def ApiRequest(js: Context => Fu[ApiResult]) = Open { implicit ctx =>
    js(ctx) map toHttp
  }

  private def toHttp(result: ApiResult)(implicit ctx: Context): Result = result match {
    case Limited => TooManyRequest(jsonError("Try again later"))
    case NoData => NotFound
    case Data(json) => get("callback") match {
      case None => Ok(json) as JSON
      case Some(callback) => Ok(s"$callback($json)") as JAVASCRIPT
    }
  }
}