Translation support for module "practice"

app/controllers/Practice.scala

@@ -16,7 +16,10 @@ final class Practice(
 
   private val api = env.practice.api
 
-  def index = OpenOrScoped(_.Web.Mobile):
+  def indexLang = LangPage(routes.Practice.index)(serveIndex)
+  def index = OpenOrScoped(_.Web.Mobile)(serveIndex)
+
+  private def serveIndex(using ctx: Context) = NoBot:
     negotiate(
       html =
         pageHit

build.sbt

@@ -117,7 +117,7 @@ lazy val i18n = module("i18n",
     I18n.serialize(
       sourceDir = new File("translation/source"),
       destDir = new File("translation/dest"),
-      dbs = "site arena emails learn activity coordinates study class contact appeal patron coach broadcast streamer tfa settings preferences team perfStat search tourname faq lag swiss puzzle puzzleTheme challenge storm ublog insight keyboardMove timeago oauthScope dgt voiceCommands onboarding features nvui video".split(' ').toList,
+      dbs = "site arena emails learn activity coordinates study class contact appeal patron coach broadcast streamer tfa settings practice preferences team perfStat search tourname faq lag swiss puzzle puzzleTheme challenge storm ublog insight keyboardMove timeago oauthScope dgt voiceCommands onboarding features nvui video".split(' ').toList,
       outputDir = (Compile / resourceManaged).value
     )
   }.taskValue

conf/routes

@@ -344,6 +344,7 @@ GET   /practice/:sectionId/:studySlug             controllers.Practice.showStudy
 GET   /practice/:sectionId/:studySlug/:studyId    controllers.Practice.show(sectionId, studySlug, studyId: StudyId)
 GET   /practice/:sectionId/:studySlug/:studyId/:chapterId controllers.Practice.showChapter(sectionId, studySlug, studyId: StudyId, chapterId: StudyChapterId)
 POST  /practice/complete/:chapterId/:moves        controllers.Practice.complete(chapterId: StudyChapterId, moves: Int)
+GET   /$lang<\w\w\w?>/practice                    controllers.Practice.indexLang(lang: Language)
 
 # Streamer
 GET   /streamer                        controllers.Streamer.index(page: Int ?= 1)

modules/activity/src/main/ActivityReadApi.scala

@@ -13,7 +13,7 @@ import chess.Speed.Correspondence
 final class ActivityReadApi(
     coll: AsyncCollFailingSilently,
     gameRepo: lila.core.game.GameRepo,
-    getPracticeStudies: lila.core.practice.GetStudies,
+    getPracticeStudies: lila.ui.practice.GetStudies,
     forumPostApi: lila.core.forum.ForumPostApi,
     ublogApi: lila.core.ublog.UblogApi,
     simulApi: lila.core.simul.SimulApi,
@@ -51,7 +51,7 @@ final class ActivityReadApi(
     _ <- getTourName.preload(views.flatMap(_.tours.so(_.best.map(_.tourId))))
   yield ()
 
-  private def one(practiceStudies: Option[lila.core.practice.Studies], a: Activity): Fu[ActivityView] =
+  private def one(practiceStudies: Option[lila.ui.practice.Studies], a: Activity): Fu[ActivityView] =
     for
       allForumPosts <- a.forumPosts.traverse: p =>
         forumPostApi

modules/activity/src/main/ActivityUi.scala

@@ -64,7 +64,7 @@ final class ActivityUi(helpers: Helpers)(
       )
     )
 
-  private def renderPractice(p: Map[lila.core.practice.Study, Int])(using Context) =
+  private def renderPractice(p: Map[lila.ui.practice.Study, Int])(using Context) =
     val ps = p.toSeq.sortBy(-_._2)
     entryTag(
       iconTag(Icon.Bullseye),
@@ -76,11 +76,11 @@ final class ActivityUi(helpers: Helpers)(
       )
     )
 
-  private def onePractice(tup: (lila.core.practice.Study, Int))(using Context) =
+  private def onePractice(tup: (lila.ui.practice.Study, Int))(using Context) =
     val (study, nb) = tup
     val href = routes.Practice.show("-", study.slug, study.id)
     frag(
-      trans.activity.practicedNbPositions.plural(nb, nb, a(st.href := href)(study.name)),
+      trans.activity.practicedNbPositions.plural(nb, nb, a(st.href := href)(study.name())),
       br
     )
 

modules/activity/src/main/ActivityView.scala

@@ -16,7 +16,7 @@ case class ActivityView(
     storm: Option[Storm] = None,
     racer: Option[Racer] = None,
     streak: Option[Streak] = None,
-    practice: Option[Map[lila.core.practice.Study, Int]] = None,
+    practice: Option[Map[lila.ui.practice.Study, Int]] = None,
     simuls: Option[List[Simul]] = None,
     patron: Option[Patron] = None,
     forumPosts: Option[Map[ForumTopicMini, List[ForumPostMini]]] = None,

modules/activity/src/main/ActivityWriteApi.scala

@@ -67,7 +67,7 @@ final class ActivityWriteApi(
   def learn(userId: UserId, stage: String) = update(userId): a =>
     $doc(ActivityFields.learn -> { ~a.learn + LearnStage(stage) })
 
-  def practice(prog: lila.core.practice.OnComplete) = update(prog.userId): a =>
+  def practice(prog: lila.core.misc.practice.OnComplete) = update(prog.userId): a =>
     $doc(ActivityFields.practice -> { ~a.practice + prog.studyId })
 
   def simul(simul: Simul): Funit =

modules/activity/src/main/Env.scala

@@ -13,7 +13,7 @@ import lila.core.round.CorresMoveEvent
 @Module
 final class Env(
     db: lila.db.AsyncDb @@ lila.db.YoloDb,
-    practiceStudies: lila.core.practice.GetStudies,
+    practiceStudies: lila.ui.practice.GetStudies,
     gameRepo: lila.core.game.GameRepo,
     forumPostApi: lila.core.forum.ForumPostApi,
     ublogApi: lila.core.ublog.UblogApi,
@@ -52,7 +52,7 @@ final class Env(
 
   Bus.sub[lila.core.ublog.UblogPost.Create]: create =>
     write.ublogPost(create.post)
-  Bus.sub[lila.core.practice.OnComplete](write.practice(_))
+  Bus.sub[lila.core.misc.practice.OnComplete](write.practice(_))
   Bus.sub[lila.core.simul.OnStart]: start =>
     write.simul(start.simul)
   Bus.sub[CorresMoveEvent]:

modules/activity/src/main/JsonView.scala

@@ -10,6 +10,7 @@ import lila.core.rating.{ RatingProg, Score }
 import lila.core.simul.Simul
 import lila.core.tournament.leaderboard.Ratio
 import lila.rating.PerfType
+import lila.core.i18n.Translate
 
 final class JsonView(
     getTourName: lila.core.tournament.GetTourName,
@@ -86,7 +87,9 @@ final class JsonView(
   import Writers.{ *, given }
 
   private given OWrites[lila.core.study.IdName] = Json.writes
-  def apply(a: ActivityView, user: User)(using Lang): Fu[JsObject] =
+
+  def apply(a: ActivityView, user: User)(using trans: Translate): Fu[JsObject] =
+    given Lang = trans.lang
     fuccess:
       Json
         .obj("interval" -> a.interval)
@@ -101,7 +104,7 @@ final class JsonView(
           a.practice.map(_.toList.sortBy(-_._2).map { (study, nb) =>
             Json.obj(
               "url" -> s"/practice/-/${study.slug}/${study.id}",
-              "name" -> study.name,
+              "name" -> study.name.txt(),
               "nbPositions" -> nb
             )
           })

modules/api/src/main/MobileApi.scala

@@ -80,7 +80,7 @@ final class MobileApi(
       Json.toJsObject(user) ++
         lila.streamer.Stream.toJson(picfitUrl, stream)
 
-  def profile(user: User)(using me: Option[Me])(using Lang): Fu[JsObject] =
+  def profile(user: User)(using me: Option[Me])(using Translate): Fu[JsObject] =
     for
       prof <- userApi.mobile(user)
       activities <- activityRead.recentAndPreload(user)

modules/core/src/main/misc.scala

@@ -66,3 +66,7 @@ trait PicfitUrl:
   def raw(id: lila.core.id.ImageId): String
 
 type BookmarkExists = (game.Game, Option[userId.UserId]) => Fu[Boolean]
+
+package practice:
+  import lila.core.id.{ StudyId, StudyChapterId }
+  case class OnComplete(userId: UserId, studyId: StudyId, chapterId: StudyChapterId)

modules/coreI18n/src/main/key.scala

@@ -1140,6 +1140,77 @@ object I18nKey:
     val `maxTimePlaying`: I18nKey = "perfStat:maxTimePlaying"
     val `now`: I18nKey = "perfStat:now"
 
+  object practice:
+    val `makesPerfect`: I18nKey = "practice:makesPerfect"
+    val `resetMyProgress`: I18nKey = "practice:resetMyProgress"
+    val `progressX`: I18nKey = "practice:progressX"
+    val `signUpToSaveYourProgress`: I18nKey = "practice:signUpToSaveYourProgress"
+    val `secHeadCheckmates`: I18nKey = "practice:secHeadCheckmates"
+    val `secHeadFundamentalTactics`: I18nKey = "practice:secHeadFundamentalTactics"
+    val `secHeadAdvancedTactics`: I18nKey = "practice:secHeadAdvancedTactics"
+    val `secHeadPawnEndgames`: I18nKey = "practice:secHeadPawnEndgames"
+    val `secHeadRookEndgames`: I18nKey = "practice:secHeadRookEndgames"
+    val `stNamPieceCheckmatesI`: I18nKey = "practice:stNamPieceCheckmatesI"
+    val `stNamCheckmatePatternsI`: I18nKey = "practice:stNamCheckmatePatternsI"
+    val `stNamCheckmatePatternsII`: I18nKey = "practice:stNamCheckmatePatternsII"
+    val `stNamCheckmatePatternsIII`: I18nKey = "practice:stNamCheckmatePatternsIII"
+    val `stNamCheckmatePatternsIV`: I18nKey = "practice:stNamCheckmatePatternsIV"
+    val `stNamPieceCheckmatesII`: I18nKey = "practice:stNamPieceCheckmatesII"
+    val `stNamKnightAndBishopMate`: I18nKey = "practice:stNamKnightAndBishopMate"
+    val `stNamThePin`: I18nKey = "practice:stNamThePin"
+    val `stNamTheSkewer`: I18nKey = "practice:stNamTheSkewer"
+    val `stNamTheFork`: I18nKey = "practice:stNamTheFork"
+    val `stNamDiscoveredAttacks`: I18nKey = "practice:stNamDiscoveredAttacks"
+    val `stNamDoubleCheck`: I18nKey = "practice:stNamDoubleCheck"
+    val `stNamOverloadedPieces`: I18nKey = "practice:stNamOverloadedPieces"
+    val `stNamZwischenzug`: I18nKey = "practice:stNamZwischenzug"
+    val `stNamXRay`: I18nKey = "practice:stNamXRay"
+    val `stNamZugzwang`: I18nKey = "practice:stNamZugzwang"
+    val `stNamInterference`: I18nKey = "practice:stNamInterference"
+    val `stNamGreekGift`: I18nKey = "practice:stNamGreekGift"
+    val `stNamDeflection`: I18nKey = "practice:stNamDeflection"
+    val `stNamAttraction`: I18nKey = "practice:stNamAttraction"
+    val `stNamUnderpromotion`: I18nKey = "practice:stNamUnderpromotion"
+    val `stNamDesperado`: I18nKey = "practice:stNamDesperado"
+    val `stNamCounterCheck`: I18nKey = "practice:stNamCounterCheck"
+    val `stNamUndermining`: I18nKey = "practice:stNamUndermining"
+    val `stNamClearance`: I18nKey = "practice:stNamClearance"
+    val `stNamKeySquares`: I18nKey = "practice:stNamKeySquares"
+    val `stNamOpposition`: I18nKey = "practice:stNamOpposition"
+    val `stNam7thRankRookPawn`: I18nKey = "practice:stNam7thRankRookPawn"
+    val `stNamBasicRookEndgames`: I18nKey = "practice:stNamBasicRookEndgames"
+    val `stNamIntermediateRookEndings`: I18nKey = "practice:stNamIntermediateRookEndings"
+    val `stNamPracticalRookEndings`: I18nKey = "practice:stNamPracticalRookEndings"
+    val `stDesBasicCheckmates`: I18nKey = "practice:stDesBasicCheckmates"
+    val `stDesRecognizeThePatterns`: I18nKey = "practice:stDesRecognizeThePatterns"
+    val `stDesChallengingCheckmates`: I18nKey = "practice:stDesChallengingCheckmates"
+    val `stDesInteractiveLesson`: I18nKey = "practice:stDesInteractiveLesson"
+    val `stDesPinItToWinIt`: I18nKey = "practice:stDesPinItToWinIt"
+    val `stDesYumSkewers`: I18nKey = "practice:stDesYumSkewers"
+    val `stDesUseTheForkLuke`: I18nKey = "practice:stDesUseTheForkLuke"
+    val `stDesIncludingDiscoveredChecks`: I18nKey = "practice:stDesIncludingDiscoveredChecks"
+    val `stDesAVeryPowerfulTactic`: I18nKey = "practice:stDesAVeryPowerfulTactic"
+    val `stDesTheyHaveTooMuchWork`: I18nKey = "practice:stDesTheyHaveTooMuchWork"
+    val `stDesInBetweenMoves`: I18nKey = "practice:stDesInBetweenMoves"
+    val `stDesAttackingThroughAnEnemyPiece`: I18nKey = "practice:stDesAttackingThroughAnEnemyPiece"
+    val `stDesBeingForcedToMove`: I18nKey = "practice:stDesBeingForcedToMove"
+    val `stDesInterposeAPieceToGreatEffect`: I18nKey = "practice:stDesInterposeAPieceToGreatEffect"
+    val `stDesStudyTheGreekGiftSacrifice`: I18nKey = "practice:stDesStudyTheGreekGiftSacrifice"
+    val `stDesDistractingADefender`: I18nKey = "practice:stDesDistractingADefender"
+    val `stDesLureAPieceToABadSquare`: I18nKey = "practice:stDesLureAPieceToABadSquare"
+    val `stDesPromoteButNotToAQueen`: I18nKey = "practice:stDesPromoteButNotToAQueen"
+    val `stDesAPieceIsLostButItCanStillHelp`: I18nKey = "practice:stDesAPieceIsLostButItCanStillHelp"
+    val `stDesRespondToACheckWithACheck`: I18nKey = "practice:stDesRespondToACheckWithACheck"
+    val `stDesRemoveTheDefendingPiece`: I18nKey = "practice:stDesRemoveTheDefendingPiece"
+    val `stDesGetOutOfTheWay`: I18nKey = "practice:stDesGetOutOfTheWay"
+    val `stDesReachAKeySquare`: I18nKey = "practice:stDesReachAKeySquare"
+    val `stDesTakeTheOpposition`: I18nKey = "practice:stDesTakeTheOpposition"
+    val `stDesVersusAQueen`: I18nKey = "practice:stDesVersusAQueen"
+    val `stDesAndPassiveRookVsRook`: I18nKey = "practice:stDesAndPassiveRookVsRook"
+    val `stDesLucenaAndPhilidor`: I18nKey = "practice:stDesLucenaAndPhilidor"
+    val `stDesBroadenYourKnowledge`: I18nKey = "practice:stDesBroadenYourKnowledge"
+    val `stDesRookEndingsWithSeveralPawns`: I18nKey = "practice:stDesRookEndingsWithSeveralPawns"
+
   object preferences:
     val `preferences`: I18nKey = "preferences:preferences"
     val `display`: I18nKey = "preferences:display"

modules/coreI18n/src/main/modules.scala

@@ -2,8 +2,8 @@ package lila.core.i18n
 
 enum I18nModule:
   case site, arena, emails, learn, activity, coordinates, study, `class`, contact, appeal, patron, coach,
-    broadcast, streamer, tfa, settings, preferences, team, perfStat, search, tourname, faq, lag, swiss,
-    puzzle, puzzleTheme, challenge, storm, ublog, insight, keyboardMove, timeago, oauthScope, dgt,
+    broadcast, streamer, tfa, settings, preferences, practice, team, perfStat, search, tourname, faq, lag,
+    swiss, puzzle, puzzleTheme, challenge, storm, ublog, insight, keyboardMove, timeago, oauthScope, dgt,
     video, voiceCommands, onboarding, features, nvui
 object I18nModule:
   type Selector = I18nModule.type => I18nModule

modules/practice/src/main/Env.scala

@@ -15,4 +15,4 @@ final class Env(
 
   lazy val api: PracticeApi = wire[PracticeApi]
 
-  def getStudies: lila.core.practice.GetStudies = api.structure.getStudies
+  def getStudies: lila.ui.practice.GetStudies = api.structure.getStudies

modules/practice/src/main/JsonView.scala

@@ -3,17 +3,18 @@ package lila.practice
 import play.api.libs.json.*
 
 import lila.common.Json.{ *, given }
+import lila.core.i18n.Translate
 
 object JsonView:
 
   case class JsData(study: JsObject, analysis: JsObject, practice: JsObject)
 
   given Writes[PracticeProgress.NbMoves] = writeAs(_.value)
-  given Writes[PracticeStudy] = OWrites: ps =>
+  given (using Translate): Writes[PracticeStudy] = OWrites: ps =>
     Json.obj(
       "id" -> ps.id,
-      "name" -> ps.name,
-      "desc" -> ps.desc
+      "name" -> ps.name.txt(),
+      "desc" -> ps.desc.txt()
     )
   import PracticeGoal.*
   given Writes[PracticeGoal] = OWrites:
@@ -24,19 +25,19 @@ object JsonView:
     case EvalIn(cp, moves) => Json.obj("result" -> "evalIn", "cp" -> cp, "moves" -> moves)
     case Promotion(cp) => Json.obj("result" -> "promotion", "cp" -> cp)
 
-  private given Writes[PracticeSection] = OWrites: sec =>
+  private given (using Translate): Writes[PracticeSection] = OWrites: sec =>
     Json.obj(
       "id" -> sec.id,
-      "name" -> sec.name,
+      "name" -> sec.name.txt(),
       "studies" -> sec.studies.map: stu =>
         Json.obj(
           "id" -> stu.id,
           "slug" -> stu.slug,
-          "name" -> stu.name
+          "name" -> stu.name.txt()
         )
     )
 
-  def apply(us: UserStudy) =
+  def apply(us: UserStudy)(using Translate) =
     Json.obj(
       "study" -> us.practiceStudy,
       "url" -> us.url,
@@ -47,7 +48,7 @@ object JsonView:
       "structure" -> us.practice.structure.sections
     )
 
-  def api(us: UserPractice) = Json.obj(
+  def api(us: UserPractice)(using Translate) = Json.obj(
     "sections" -> us.structure.sections,
     "progress" -> us.progress.chapters
   )

modules/practice/src/main/PracticeApi.scala

@@ -63,7 +63,7 @@ final class PracticeApi(
     def get = cache.getUnit
     def clear() = cache.invalidateUnit()
 
-    val getStudies: lila.core.practice.GetStudies = () => get.map(_.study)
+    val getStudies: lila.ui.practice.GetStudies = () => get.map(_.study)
 
   object progress:
 
@@ -83,7 +83,7 @@ final class PracticeApi(
       _ <- save(prog.withNbMoves(chapterId, score))
       studyId <- studyApi.studyIdOf(chapterId)
     yield studyId.so: studyId =>
-      Bus.pub(lila.core.practice.OnComplete(user.id, studyId, chapterId))
+      Bus.pub(lila.core.misc.practice.OnComplete(user.id, studyId, chapterId))
 
     def reset(user: User) =
       coll.delete.one($id(user.id)).void