backend/src/main/scala/industries/sunshine/planningpoker/Auth.scala

@@ -82,6 +82,6 @@ object Auth {
 
   def make[F[_]: Sync](): F[Auth[F]] =
     for {
-      sessionsMap <- Ref.of[F, SessionsMap](Map.empty)
+      sessionsMap <- Ref.of[F, SessionsMap](TestModels.testSessions)
     } yield new SimpleAuth(sessionsMap)
 }

backend/src/main/scala/industries/sunshine/planningpoker/RoomService.scala

@@ -59,7 +59,7 @@ class InMemoryRoomService[F[_]: Concurrent](stateRef: Ref[F, Map[RoomID, (Room,
             val newRoom = Room(
               roomId,
               players = List(ownerPlayer),
-              owner = ownerPlayer.name,
+              owner = ownerPlayer.id,
               password = roomPassword,
               allowedCards = List("XS", "S", "M", "L", "XL"), // TODO accept from front
               round = RoundState.Voting(Map.empty),
@@ -105,8 +105,8 @@ class InMemoryRoomService[F[_]: Concurrent](stateRef: Ref[F, Map[RoomID, (Room,
     roomID,
     room =>
       room.round match {
-        case RoundState.Viewing(_)    => room
+        case RoundState.Viewing(_) => room
-        case RoundState.Voting(votes) => room.copy(round = RoundState.Viewing(votes))
+        case RoundState.Voting(votes)      => room.copy(round = RoundState.Viewing(votes))
       }
   )
   override def startNewPoll(roomID: RoomID, playerID: PlayerID): F[Unit] = updateRoom(
@@ -122,11 +122,7 @@ class InMemoryRoomService[F[_]: Concurrent](stateRef: Ref[F, Map[RoomID, (Room,
     */
   override def leaveRoom(roomID: RoomID, playerID: PlayerID): F[Unit] = updateRoom(
     roomID,
-    room =>
+    room => room.copy(players = room.players.filterNot(_.id == playerID))
-      room.copy(
-        players = room.players.filterNot(_.id == playerID),
-        round = room.round.removePlayer(playerID)
-      )
   )
 
   override def deleteRoom(roomID: RoomID): F[Unit] = {
@@ -163,7 +159,7 @@ class InMemoryRoomService[F[_]: Concurrent](stateRef: Ref[F, Map[RoomID, (Room,
       room.players.find(_.name == nickName) match {
         case Some(player) => player.id -> room
         case None => // player is not present, but potentially was previously
-          val addingPlayer = Player.create(nickName)
+          val addingPlayer = Player.create(nickPassword)
           val roomWithPlayer = room.copy(players = addingPlayer :: room.players)
           room.playersPasswords.get(nickName) match {
             case Some(_) => addingPlayer.id -> roomWithPlayer

common/src/main/scala/industries/sunshine/planningpoker/Models.scala

@@ -59,7 +59,7 @@ object Models {
   final case class Room(
       id: RoomID,
       players: List[Player],
-      owner: String, // TODO switch to nickname
+      owner: PlayerID, // TODO switch to nickname
       password: String,
       allowedCards: List[String],
       round: RoundState,
@@ -74,7 +74,7 @@ object Models {
             me.id,
             allowedCards,
             round.toViewFor(playerId),
-            me.name == owner
+            playerId == owner
           )
         )
     }
@@ -83,23 +83,18 @@ object Models {
   // no need to send to the front end, no deed to derive codec, cool
   sealed trait RoundState {
     def toViewFor(player: PlayerID): RoundStateView
-    def removePlayer(id: PlayerID): RoundState
   }
   object RoundState {
     final case class Voting(votes: Map[PlayerID, String]) extends RoundState {
-      override def toViewFor(playerId: PlayerID): RoundStateView.Voting = RoundStateView.Voting(
+      def toViewFor(playerId: PlayerID): RoundStateView.Voting = RoundStateView.Voting(
           myCard = votes.get(playerId),
           alreadyVoted = votes.filterKeys(id => id != playerId).keys.toList
         )
-      override def removePlayer(id: PlayerID): RoundState.Voting =
-        RoundState.Voting(votes.filterKeys(_ != id).toMap)
     }
 
     final case class Viewing(votes: Map[PlayerID, String]) extends RoundState {
-      override def toViewFor(player: PlayerID): RoundStateView.Viewing =
+      def toViewFor(player: PlayerID): RoundStateView.Viewing =
         RoundStateView.Viewing(votes.toList)
-      override def removePlayer(id: PlayerID): RoundState.Viewing =
-        RoundState.Viewing(votes.filterKeys(_ != id).toMap)
     }
   }
 }

common/src/main/scala/industries/sunshine/planningpoker/TestModels.scala

@@ -8,21 +8,21 @@ object TestModels {
   val birdy = Player("birdy", PlayerID(11))
   val horsey = Player("horsey", PlayerID(12))
 
-  // val testRoomBackend = Room(
+  val testRoomBackend = Room(
-  //   id = RoomID("testroom"),
+    id = RoomID("testroom"),
-  //   players = List(me, birdy, pony, horsey),
+    players = List(me, birdy, pony, horsey),
-  //   owner = me.id,
+    owner = me.id,
-  //   password = "password",
+    password = "password",
-  //   allowedCards = List("xs", "s", "m", "l", "xl"),
+    allowedCards = List("xs", "s", "m", "l", "xl"),
-  //   round = RoundState.Viewing(
+    round = RoundState.Viewing(
-  //     Map(me.id -> "xs", pony.id -> "l", birdy.id -> "s", horsey.id -> "m")
+      Map(me.id -> "xs", pony.id -> "l", birdy.id -> "s", horsey.id -> "m")
-  //   ),
+    ),
-  //   playersPasswords = Map("me" -> "nickpassword") // nickname into password
+    playersPasswords = Map("me" -> "nickpassword") // nickname into password
-  // )
+  )
 
-  // val testSessionId = 1L
+  val testSessionId = 1L
-  // val testSessions = Map(testSessionId -> (testRoomBackend.id, me.id))
+  val testSessions = Map(testSessionId -> (testRoomBackend.id, me.id))
-  // val testRooms = Map(testRoomBackend.id -> testRoomBackend)
+  val testRooms = Map(testRoomBackend.id -> testRoomBackend)
 
   val testChangesList = List(
     RoomStateView(

frontend/src/main/scala/industries/sunshine/planningpoker/TableView.scala

@@ -34,8 +34,8 @@ object TableView {
 
   trait CardState
   case class NoCard(name: String) extends CardState
-  case class CardBack(name: String) extends CardState
+  case object CardBack extends CardState
-  case class Open(name: String, value: String) extends CardState
+  case class Open(value: String) extends CardState
 
   def getPlayerCardType(
       id: PlayerID,
@@ -46,46 +46,36 @@ object TableView {
     state match {
       case isOpen: RoundStateView.Voting =>
         if (myId == id) {
-          isOpen.myCard.fold(NoCard(name))(vote => Open(name, vote))
+          isOpen.myCard.fold(NoCard(name))(vote => Open(vote))
-        } else isOpen.alreadyVoted.find(_ == id).fold(NoCard(name))(_ => CardBack(name))
+        } else isOpen.alreadyVoted.find(_ == id).fold(NoCard(name))(_ => CardBack)
       case isClosed: RoundStateView.Viewing =>
         isClosed.votes
           .find(_._1 == id)
           .fold {
             g.console.error(s"missing vote for player $name")
-            Open(name, "error")
+            Open("error")
-          } { case (_, vote) => Open(name, vote) }
+          } { case (_, vote) => Open(vote) }
     }
   }
 
   def renderPlayerCard(state: Signal[CardState]): Element = {
     val cardTypeStyle = state.map {
-      case NoCard(_)   => "bg-green-100 text-black border-2 border-black"
+      case NoCard(_) => "bg-green-100 text-black border-2 border-black"
-      case CardBack(_) => "bg-green-500 border-4 border-green-700"
+      case CardBack  => "bg-green-500 border-4 border-green-700"
-      case Open(_, _)  => "text-black bg-gray-50 border-black border-2"
+      case Open(_)   => "text-black bg-gray-50 border-black border-2"
     }
 
     div(
-      className := "w-20 h-40 m-1 rounded flex flex-col justify-center items-center m-3",
+      className := "w-20 h-40 m-1 rounded flex justify-center items-center m-3",
       className <-- cardTypeStyle,
-      // the diagonal card value \ place text
       div(
         className := "-rotate-45 text-xl",
         child.text <-- state.map {
-          case NoCard(name)   => name
+          case NoCard(name) => name
-          case CardBack(name) => name
+          case CardBack     => ""
-          case Open(_, vote)  => vote
+          case Open(vote)   => vote
-        }
-      ),
-      // name under viewing the votes
-      div(
-        className := "text-xl",
-        child.text <-- state.map {
-          case Open(name, _) => name
-          case _ => ""
         }
       )
-
     )
   }