Allow retrieval of stats

src/main/scala/BallDontLie.scala

@@ -52,11 +52,14 @@ case class EndpointResponse[T](data: T, meta: ResponseMetadata) {
 object EndpointResponse {
   type ListOfTeams = List[Team]
   type ListOfGames = List[GameData]
+  type ListOfStats = List[PlayerGameStats]
   type TeamsResponse = EndpointResponse[ListOfTeams]
   type GamesResponse = EndpointResponse[ListOfGames]
+  type StatsResponse = EndpointResponse[ListOfStats]
 
   val teams_per_page = 25
   val games_per_page = 25
+  val stats_per_page = 25
 
   def doPaginatedRequest[T: Reader](
       endpoint: String,
@@ -131,4 +134,15 @@ object EndpointResponse {
       )
     })
   }
+
+  def getStats(game_ids: List[Int]): ListOfStats = {
+    implicit val gamesResponseR: Reader[StatsResponse] = macroR[StatsResponse]
+
+    doPaginatedRequest[StatsResponse](
+      "https://www.balldontlie.io/api/v1/stats",
+      1,
+      stats_per_page,
+      Map(("game_ids" -> game_ids))
+    ).data
+  }
 }

src/main/scala/Extract.scala

@@ -1,9 +1,12 @@
 package extract
 
 import balldontlie._
-import game.GameData
+import game.PlayerGameStats
 
 object Extract {
+  val stats_output = os.pwd / "stats.json"
+  val games_output = os.pwd / "games.json"
+
   val selectedTeams = List(
     "Phoenix Suns",
     "Atlanta Hawks",
@@ -11,10 +14,16 @@ object Extract {
     "Milwaukee Bucks"
   ).take(1)
 
-  val getStats: List[GameData] = {
-    val teamIds = EndpointResponse.getTeams()
+  def getStats() = {
+    val teamIds = EndpointResponse
+      .getTeams()
       .filter(team => selectedTeams.contains(team.full_name))
       .map(_.id)
-    EndpointResponse.getGames(2021, teamIds)
+    val gameList = EndpointResponse.getGames(2021, teamIds)
+
+    val stats = EndpointResponse.getStats(gameList.map(_.id))
+
+    Utils.writeToFile(PlayerGameStats.as_json_value(stats), stats_output)
+    Utils.writeToFile(gameList, games_output)
   }
 }

src/main/scala/Games.scala

@@ -30,3 +30,65 @@ case class GameData(
 object GameData {
   implicit val gameDataRW: ReadWriter[GameData] = macroRW[GameData]
 }
+
+case class Player(
+    id: Int,
+    first_name: String,
+    last_name: String,
+    position: String,
+    team_id: Int
+)
+object Player {
+  implicit val playerRW: ReadWriter[Player] = macroRW[Player]
+}
+
+case class PlayerGameStats(
+    id: Int,
+    ast: Int,
+    blk: Int,
+    dreb: Int,
+    fg3_pct: Float,
+    fg3a: Int,
+    fg3m: Int,
+    fg_pct: Float,
+    fga: Int,
+    fgm: Int,
+    ft_pct: Float,
+    fta: Int,
+    ftm: Int,
+    min: String, // "36:49"
+    oreb: Int,
+    pf: Int,
+    pts: Int,
+    reb: Int,
+    stl: Int,
+    turnover: Int,
+    player: Player,
+    team: Map[String, String],
+    game: Map[String, String]
+) {
+  val gameId = game("id").toInt
+  val teamId = team("id").toInt
+
+  def as_json_value(): ujson.Value = {
+    val value = upickle.default.writeJs[PlayerGameStats](this)
+    value.obj.put("game_id", gameId)
+    value.obj.put("team_id", teamId)
+    value.obj.put("player_id", player.id)
+    value.obj.put("player_first_name", player.first_name)
+    value.obj.put("player_last_name", player.last_name)
+    value.obj.put("player_position", player.position)
+    value.obj.put("player_team_id", player.team_id)
+
+    value
+  }
+}
+
+object PlayerGameStats {
+  implicit val playerGameStatsRW: ReadWriter[PlayerGameStats] =
+    macroRW[PlayerGameStats]
+
+  def as_json_value(stats_list: List[PlayerGameStats]): ujson.Value = {
+    upickle.default.writeJs(stats_list.map(_.as_json_value()))
+  }
+}