267 lines
8.2 KiB
Scala
267 lines
8.2 KiB
Scala
package controllers
|
|
|
|
import play.api.libs.json._
|
|
import scala.util.chaining._
|
|
|
|
import lila.api.Context
|
|
import lila.app._
|
|
import lila.common.config.MaxPerSecond
|
|
import lila.puzzle.{ PuzzleId, Result, Puzzle => PuzzleModel, UserInfos }
|
|
import views._
|
|
|
|
final class Puzzle(
|
|
env: Env,
|
|
apiC: => Api
|
|
) extends LilaController(env) {
|
|
|
|
private def renderJson(
|
|
puzzle: PuzzleModel,
|
|
userInfos: Option[UserInfos],
|
|
mode: String,
|
|
voted: Option[Boolean],
|
|
round: Option[lila.puzzle.Round] = None
|
|
)(implicit ctx: Context): Fu[JsObject] =
|
|
env.puzzle.jsonView(
|
|
puzzle = puzzle,
|
|
userInfos = userInfos,
|
|
round = round,
|
|
mode = mode,
|
|
mobileApi = ctx.mobileApiVersion,
|
|
voted = voted
|
|
)
|
|
|
|
private def renderShow(puzzle: PuzzleModel, mode: String)(implicit ctx: Context) =
|
|
env.puzzle userInfos ctx.me flatMap { infos =>
|
|
renderJson(puzzle = puzzle, userInfos = infos, mode = mode, voted = none) map { json =>
|
|
EnableSharedArrayBuffer(
|
|
Ok(views.html.puzzle.show(puzzle, data = json, pref = env.puzzle.jsonView.pref(ctx.pref)))
|
|
)
|
|
}
|
|
}
|
|
|
|
def daily =
|
|
Open { implicit ctx =>
|
|
NoBot {
|
|
OptionFuResult(env.puzzle.daily.get flatMap {
|
|
_.map(_.id) ?? env.puzzle.api.puzzle.find
|
|
}) { puzzle =>
|
|
negotiate(
|
|
html = renderShow(puzzle, "play"),
|
|
api = _ => puzzleJson(puzzle) map { Ok(_) }
|
|
) map NoCache
|
|
}
|
|
}
|
|
}
|
|
|
|
def home =
|
|
Open { implicit ctx =>
|
|
NoBot {
|
|
env.puzzle.selector(ctx.me) flatMap { puzzle =>
|
|
renderShow(puzzle, if (ctx.isAuth) "play" else "try")
|
|
}
|
|
}
|
|
}
|
|
|
|
def show(id: PuzzleId) =
|
|
Open { implicit ctx =>
|
|
NoBot {
|
|
OptionFuResult(env.puzzle.api.puzzle find id) { puzzle =>
|
|
renderShow(puzzle, "play")
|
|
}
|
|
}
|
|
}
|
|
|
|
def load(id: PuzzleId) =
|
|
Open { implicit ctx =>
|
|
NoBot {
|
|
XhrOnly {
|
|
OptionFuOk(env.puzzle.api.puzzle find id)(puzzleJson) map (_ as JSON)
|
|
}
|
|
}
|
|
}
|
|
|
|
private def puzzleJson(puzzle: PuzzleModel)(implicit ctx: Context) =
|
|
env.puzzle userInfos ctx.me flatMap { infos =>
|
|
renderJson(puzzle, infos, if (ctx.isAuth) "play" else "try", voted = none)
|
|
}
|
|
|
|
// XHR load next play puzzle
|
|
def newPuzzle =
|
|
Open { implicit ctx =>
|
|
NoBot {
|
|
XhrOnly {
|
|
env.puzzle.selector(ctx.me) flatMap puzzleJson map { json =>
|
|
Ok(json) as JSON
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// mobile app BC
|
|
def round(id: PuzzleId) =
|
|
OpenBody { implicit ctx =>
|
|
implicit val req = ctx.body
|
|
OptionFuResult(env.puzzle.api.puzzle find id) { puzzle =>
|
|
lila.mon.puzzle.round.attempt(puzzle.mate, ctx.isAuth, "old")
|
|
env.puzzle.forms.round
|
|
.bindFromRequest()
|
|
.fold(
|
|
jsonFormError,
|
|
resultInt => {
|
|
val result = Result(resultInt == 1)
|
|
ctx.me match {
|
|
case Some(me) =>
|
|
for {
|
|
isStudent <- env.clas.api.student.isStudent(me.id)
|
|
(round, mode) <-
|
|
env.puzzle.finisher(puzzle, me, result, mobile = true, isStudent = isStudent)
|
|
me2 <- if (mode.rated) env.user.repo byId me.id map (_ | me) else fuccess(me)
|
|
infos <- env.puzzle userInfos me2
|
|
voted <- ctx.me.?? { env.puzzle.api.vote.value(puzzle.id, _) }
|
|
data <- renderJson(puzzle, infos.some, "view", voted = voted, round = round.some)
|
|
} yield {
|
|
val d2 = if (mode.rated) data else data ++ Json.obj("win" -> result.win)
|
|
Ok(d2)
|
|
}
|
|
case None =>
|
|
env.puzzle.finisher.incPuzzleAttempts(puzzle)
|
|
renderJson(puzzle, none, "view", voted = none) map { data =>
|
|
val d2 = data ++ Json.obj("win" -> result.win)
|
|
Ok(d2)
|
|
}
|
|
}
|
|
}
|
|
) map (_ as JSON)
|
|
}
|
|
}
|
|
|
|
// new API
|
|
def round2(id: PuzzleId) =
|
|
OpenBody { implicit ctx =>
|
|
NoBot {
|
|
implicit val req = ctx.body
|
|
OptionFuResult(env.puzzle.api.puzzle find id) { puzzle =>
|
|
lila.mon.puzzle.round.attempt(puzzle.mate, ctx.isAuth, "new")
|
|
env.puzzle.forms.round
|
|
.bindFromRequest()
|
|
.fold(
|
|
jsonFormError,
|
|
resultInt =>
|
|
ctx.me match {
|
|
case Some(me) =>
|
|
for {
|
|
isStudent <- env.clas.api.student.isStudent(me.id)
|
|
(round, mode) <- env.puzzle.finisher(
|
|
puzzle = puzzle,
|
|
user = me,
|
|
result = Result(resultInt == 1),
|
|
mobile = lila.api.Mobile.Api.requested(ctx.req),
|
|
isStudent = isStudent
|
|
)
|
|
me2 <- if (mode.rated) env.user.repo byId me.id map (_ | me) else fuccess(me)
|
|
infos <- env.puzzle userInfos me2
|
|
voted <- ctx.me.?? { env.puzzle.api.vote.value(puzzle.id, _) }
|
|
} yield Ok(
|
|
Json.obj(
|
|
"user" -> lila.puzzle.JsonView.infos(isOldMobile = false)(infos),
|
|
"round" -> lila.puzzle.JsonView.round(round),
|
|
"voted" -> voted
|
|
)
|
|
)
|
|
case None =>
|
|
env.puzzle.finisher.incPuzzleAttempts(puzzle)
|
|
Ok(Json.obj("user" -> false)).fuccess
|
|
}
|
|
) map (_ as JSON)
|
|
}
|
|
}
|
|
}
|
|
|
|
def vote(id: PuzzleId) =
|
|
AuthBody { implicit ctx => me =>
|
|
NoBot {
|
|
implicit val req = ctx.body
|
|
env.puzzle.forms.vote
|
|
.bindFromRequest()
|
|
.fold(
|
|
jsonFormError,
|
|
vote =>
|
|
env.puzzle.api.vote.find(id, me) flatMap { v =>
|
|
env.puzzle.api.vote.update(id, me, v, vote == 1)
|
|
} map { case (p, a) =>
|
|
if (vote == 1) lila.mon.puzzle.vote.up.increment()
|
|
else lila.mon.puzzle.vote.down.increment()
|
|
Ok(Json.arr(a.value, p.vote.sum))
|
|
}
|
|
) map (_ as JSON)
|
|
}
|
|
}
|
|
|
|
/* Mobile API: select a bunch of puzzles for offline use */
|
|
def batchSelect =
|
|
Auth { implicit ctx => me =>
|
|
negotiate(
|
|
html = notFound,
|
|
api = _ =>
|
|
for {
|
|
puzzles <- env.puzzle.batch.select(
|
|
me,
|
|
nb = getInt("nb") getOrElse 50 atLeast 1 atMost 100,
|
|
after = getInt("after")
|
|
)
|
|
userInfo <- env.puzzle userInfos me
|
|
json <- env.puzzle.jsonView.batch(puzzles, userInfo)
|
|
} yield Ok(json) as JSON
|
|
)
|
|
}
|
|
|
|
/* Mobile API: tell the server about puzzles solved while offline */
|
|
def batchSolve =
|
|
AuthBody(parse.json) { implicit ctx => me =>
|
|
import lila.puzzle.PuzzleBatch._
|
|
ctx.body.body
|
|
.validate[SolveData]
|
|
.fold(
|
|
err => BadRequest(err.toString).fuccess,
|
|
data =>
|
|
negotiate(
|
|
html = notFound,
|
|
api = _ =>
|
|
for {
|
|
_ <- env.puzzle.batch.solve(me, data)
|
|
me2 <- env.user.repo byId me.id map (_ | me)
|
|
infos <- env.puzzle userInfos me2
|
|
} yield Ok(
|
|
Json.obj(
|
|
"user" -> lila.puzzle.JsonView.infos(isOldMobile = false)(infos)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
def frame =
|
|
Action.async { implicit req =>
|
|
env.puzzle.daily.get map {
|
|
case None => NotFound
|
|
case Some(daily) => html.puzzle.embed(daily)
|
|
}
|
|
}
|
|
|
|
def activity =
|
|
Scoped(_.Puzzle.Read) { req => me =>
|
|
val config = lila.puzzle.PuzzleActivity.Config(
|
|
user = me,
|
|
max = getInt("max", req) map (_ atLeast 1),
|
|
perSecond = MaxPerSecond(20)
|
|
)
|
|
apiC
|
|
.GlobalConcurrencyLimitPerIpAndUserOption(req, me.some)(env.puzzle.activity.stream(config)) {
|
|
source =>
|
|
Ok.chunked(source).as(ndJsonContentType) pipe noProxyBuffer
|
|
}
|
|
.fuccess
|
|
}
|
|
|
|
}
|