Package and fixes

Author: dacr

Makefile

@@ -0,0 +1,3 @@
+all:
+	sbt universal:packageXzTarball
+

build.sbt

@@ -81,7 +81,9 @@ lazy val webapi =
     .dependsOn(gameLogic)
     .dependsOn(wordGenerator)
     .dependsOn(dictionary)
+    .enablePlugins(JavaServerAppPackaging)
     .settings(
+      Universal / packageName := "zwords",
       sharedSettings,
       libraryDependencies ++= Seq(
         "com.softwaremill.sttp.tapir" %% "tapir-zio"             % versions.tapir,

gamelogic/src/main/scala/fr/janalyse/zwords/gamelogic/Game.scala

@@ -5,7 +5,7 @@ import fr.janalyse.zwords.wordgen.WordGeneratorService
 import zio.*
 import zio.json.*
 
-import java.time.Instant
+import java.time.OffsetDateTime
 import java.util.UUID
 import scala.collection.LazyZip2
 import scala.io.AnsiColor.*
@@ -170,7 +170,7 @@ object GameStorageIssue:
   given JsonCodec[GameStorageIssue]          = DeriveJsonCodec.gen
   def apply(th: Throwable): GameStorageIssue = GameStorageIssue(th.getMessage)
 
-case class Game(uuid: UUID, hiddenWord: String, board: Board, createdDate: Instant, possibleWordsCount: Int):
+case class Game(uuid: UUID, hiddenWord: String, board: Board, createdDate: OffsetDateTime, possibleWordsCount: Int):
 
   override def toString: String = board.toString + s" $YELLOW($possibleWordsCount)$RESET"
 
@@ -195,7 +195,7 @@ case class Game(uuid: UUID, hiddenWord: String, board: Board, createdDate: Insta
     yield copy(board = newBoard, possibleWordsCount = possibleWords.size)
 
 object Game:
-  def makeDefaultWordMask(word:String):String =  (word.head +: word.tail.map(_ => "_")).mkString
+  def makeDefaultWordMask(word: String): String = (word.head +: word.tail.map(_ => "_")).mkString
 
   def init(maxAttemptsCount: Int): ZIO[WordGeneratorService & Random & Clock, GameIssue | GameInternalIssue, Game] =
     for {
@@ -210,8 +210,8 @@ object Game:
   def init(hiddenWord: String, wordMask: String, maxAttemptsCount: Int): ZIO[WordGeneratorService & Random & Clock, GameIssue | GameInternalIssue, Game] =
     for {
       wordGen       <- ZIO.service[WordGeneratorService]
-      createdDate   <- Clock.instant
-      _             <- Random.setSeed(createdDate.toEpochMilli)
+      createdDate   <- Clock.currentDateTime
+      _             <- Random.setSeed(createdDate.toInstant.toEpochMilli)
       uuid          <- Random.nextUUID
       board          = Board(wordMask, maxAttemptsCount)
       possibleWords <- wordGen.matchingWords(wordMask, Map.empty, Map.empty).mapError(th => GameWordGeneratorIssue(th))

project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("com.github.sbt"   % "sbt-native-packager" % "1.9.9")

webapi/src/main/scala/fr/janalyse/zwords/webapi/PlayerStoreService.scala

@@ -2,9 +2,11 @@ package fr.janalyse.zwords.webapi
 
 import zio.*
 import zio.json.*
+
 import java.util.UUID
 import fr.janalyse.zwords.gamelogic.Game
-import java.time.Instant
+
+import java.time.OffsetDateTime
 
 case class PlayStats(
   playedCount: Int = 0,
@@ -19,20 +21,20 @@ object PlayStats {
 case class Player(
   uuid: UUID,
   pseudo: String,
-  createdOn: Instant,
+  createdOn: OffsetDateTime,
   currentGame: Game,
   stats: PlayStats
 )
 
 trait PlayerStoreService {
   def getPlayer(playerUUID: UUID): Task[Option[Player]]
-  def upsertPlayer(player: Player): Task[Unit]
+  def upsertPlayer(player: Player): Task[Player]
   def stats: Task[PlayStats]
 }
 
 object PlayerStoreService {
   def getPlayer(playerUUID: UUID): RIO[PlayerStoreService, Option[Player]] = ZIO.serviceWithZIO(_.getPlayer(playerUUID))
-  def upsertPlayer(player: Player): RIO[PlayerStoreService, Unit]          = ZIO.serviceWithZIO(_.upsertPlayer(player))
+  def upsertPlayer(player: Player): RIO[PlayerStoreService, Player]        = ZIO.serviceWithZIO(_.upsertPlayer(player))
   def stats: RIO[PlayerStoreService, PlayStats]                            = ZIO.serviceWithZIO(_.stats)
 
   val live = (for {
@@ -47,10 +49,10 @@ case class PlayerStoreServiceLive(ref: Ref[Map[UUID, Player]]) extends PlayerSto
       mayBePlayer = players.get(playerUUID)
     } yield mayBePlayer
 
-  def upsertPlayer(player: Player): Task[Unit] =
+  def upsertPlayer(player: Player): Task[Player] =
     for {
       players <- ref.getAndUpdate(players => players + (player.uuid -> player))
-    } yield ()
+    } yield player
 
   def stats: Task[PlayStats] =
     for {

webapi/src/main/scala/fr/janalyse/zwords/webapi/WebApiApp.scala

@@ -14,7 +14,8 @@ import zio.*
 import zio.json.*
 import zio.json.ast.*
 
-import java.time.Instant
+import java.time.OffsetDateTime
+import java.time.temporal.ChronoField
 import java.util.UUID
 
 case class GameGivenWord(
@@ -97,7 +98,7 @@ object PlayerCreate {
 
 case class PlayerGet(
   pseudo: String,
-  createdOn: Instant,
+  createdOn: OffsetDateTime,
   stats: PlayStats
 )
 object PlayerGet    {
@@ -113,8 +114,8 @@ object WebApiApp extends ZIOAppDefault {
     for {
       store      <- ZIO.service[PlayerStoreService]
       game       <- Game.init(6)
-      created    <- Clock.instant
-      _          <- Random.setSeed(created.toEpochMilli)
+      created    <- Clock.currentDateTime
+      _          <- Random.setSeed(created.toInstant.toEpochMilli)
       playerUUID <- Random.nextUUID
       player      = Player(uuid = playerUUID, pseudo = playerCreate.pseudo, createdOn = created, currentGame = game, stats = PlayStats())
       state      <- store.upsertPlayer(player).mapError(th => GameStorageIssue(th))
@@ -168,12 +169,29 @@ object WebApiApp extends ZIOAppDefault {
 
   // -------------------------------------------------------------------------------------------------------------------
 
+  def sameDay(date1: OffsetDateTime, date2: OffsetDateTime): Boolean = {
+    val fields = List(
+      ChronoField.YEAR_OF_ERA,
+      ChronoField.MONTH_OF_YEAR,
+      ChronoField.DAY_OF_MONTH
+    )
+    fields.forall(field => date1.get(field) == date2.get(field))
+  }
+
   def gameGet(playerUUID: String): ZIO[GameEnv, GameIssue | GameInternalIssue, PlayerGameState] =
     for {
-      store  <- ZIO.service[PlayerStoreService]
-      uuid   <- ZIO.attempt(UUID.fromString(playerUUID)).mapError(th => GameInvalidUUID(playerUUID))
-      player <- store.getPlayer(playerUUID = uuid).some.mapError(_ => GameNotFound(playerUUID))
-    } yield PlayerGameState.fromPlayer(player)
+      store        <- ZIO.service[PlayerStoreService]
+      uuid         <- ZIO.attempt(UUID.fromString(playerUUID)).mapError(th => GameInvalidUUID(playerUUID))
+      playerBefore <- store.getPlayer(playerUUID = uuid).some.mapError(_ => GameNotFound(playerUUID))
+      today        <- Clock.currentDateTime
+      isSameDay    <- ZIO.attempt(sameDay(playerBefore.currentGame.createdDate, today)).mapError(th => GameStorageIssue(th))
+      playerAfter  <- if (isSameDay) ZIO.succeed(playerBefore)
+                      else
+                        for {
+                          newGame       <- Game.init(6)
+                          updatedPlayer <- store.upsertPlayer(playerBefore.copy(currentGame = newGame)).mapError(th => GameStorageIssue(th))
+                        } yield updatedPlayer
+    } yield PlayerGameState.fromPlayer(playerAfter)
 
   val gameGetEndPoint =
     endpoint
@@ -272,11 +290,10 @@ object WebApiApp extends ZIOAppDefault {
 
   val server = for {
     clientResources             <- System.env("ZWORDS_CLIENT_RESOURCES_PATH").some
-    clientSideEndPoint           = fileGetServerEndpoint("index.html")(s"$clientResources/index.html").widen[GameEnv]
-    clientSideResourcesEndPoints = filesGetServerEndpoint("static")(s"$clientResources/static").widen[GameEnv]
-    clientSideRoutes             = List(clientSideEndPoint, clientSideEndPoint)
+    clientSideResourcesEndPoints = filesGetServerEndpoint(emptyInput)(clientResources).widen[GameEnv]
+    clientSideRoutes             = List(clientSideResourcesEndPoints)
     httpApp                      = ZioHttpInterpreter().toHttp(gameRoutes ++ apiDocRoutes ++ clientSideRoutes)
-    zservice                    <- zhttp.service.Server.start(8080, httpApp)
+    zservice                    <- zhttp.service.Server.start(8090, httpApp)
   } yield zservice
 
   override def run =