refactor champions, position filters, champion card...

apps/lol_analytics/lib/lol_analytics/analyzer/base_analyzer.ex

@@ -1,3 +0,0 @@
-defmodule LolAnalytics.Analyzer do
-  @callback analyze(:url, path :: String.t()) :: :ok
-end

apps/lol_analytics/lib/lol_analytics/analyzer/champion_analyzer.ex

@@ -1,50 +0,0 @@
-defmodule LolAnalytics.Analyzer.ChampionAnalyzer do
-  alias Hex.HTTP
-  @behaviour LolAnalytics.Analyzer
-
-  def analyze_all_matches do
-    Storage.MatchStorage.S3MatchStorage.list_files("ranked")
-    |> Enum.map(& &1.key)
-    |> Enum.each(fn path ->
-      LolAnalytics.Analyzer.ChampionAnalyzer.analyze(:url, "http://localhost:9000/ranked/#{path}")
-    end)
-  end
-
-  @doc """
-  iex> LolAnalytics.Analyzer.ChampionAnalyzer.analyze(:url, "http://localhost:9000/ranked/14.9.580.2108/EUW1_6923309745.json")
-  """
-  @impl true
-  @spec analyze(atom(), String.t()) :: :ok
-  def analyze(:url, path) do
-    data = HTTPoison.get!(path)
-    analyze(:data, data.body)
-    :ok
-  end
-
-  @impl true
-  @spec analyze(atom(), any()) :: list(LoLAPI.Model.Participant.t())
-  def analyze(:data, data) do
-    decoded_match = Poison.decode!(data, as: %LoLAPI.Model.MatchResponse{})
-    participants = decoded_match.info.participants
-    version = extract_game_version(decoded_match)
-
-    participants
-    |> Enum.each(fn participant = %LoLAPI.Model.Participant{} ->
-      if participant.teamPosition != "" do
-        LolAnalytics.ChampionWinRate.ChampionWinRateRepo.add_champion_win_rate(
-          participant.championId,
-          version,
-          participant.teamPosition,
-          participant.win
-        )
-      end
-    end)
-  end
-
-  defp extract_game_version(game_data) do
-    game_data.info.gameVersion
-    |> String.split(".")
-    |> Enum.take(2)
-    |> Enum.join(".")
-  end
-end

apps/lol_analytics/lib/lol_analytics/champion_win_rate/champion_win_rate_repo.ex

@@ -46,7 +46,7 @@ defmodule LolAnalytics.ChampionWinRate.ChampionWinRateRepo do
     Repo.all(ChampionWinRateSchema)
   end
 
-  def get_champion_win_rate(champion_id, patch) do
+  def get_champion_win_rate(champion_id, _patch) do
     champion_query =
       from cwr in LolAnalytics.ChampionWinRate.ChampionWinRateSchema,
         where: cwr.champion_id == ^champion_id

apps/lol_analytics/lib/lol_analytics/dimensions/champion/champion_metadata.ex

@@ -0,0 +1,41 @@
+defmodule LolAnalytics.Dimensions.Champion.ChampionMetadata do
+  alias LolAnalytics.Dimensions.Champion.ChampionRepo
+  @champions_data_url "https://ddragon.leagueoflegends.com/cdn/14.11.1/data/en_US/champion.json"
+
+  def update_metadata() do
+    {:ok, %{"data" => data}} = get_champions()
+
+    data
+    |> Enum.each(&save_metadata/1)
+  end
+
+  defp get_champions() do
+    with {:ok, resp} <- HTTPoison.get(@champions_data_url),
+         data <- Poison.decode(resp.body) do
+      data
+    else
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp save_metadata({_champion, info}) do
+    %{
+      "image" => %{
+        "full" => full_image
+      },
+      "name" => name,
+      "key" => key_string
+    } = info
+
+    attrs = %{
+      image: full_image,
+      name: name
+    }
+
+    {champion_id, _} = Integer.parse(key_string)
+
+    ChampionRepo.update(champion_id, attrs)
+
+    info
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/champion/champion_repo.ex

@@ -0,0 +1,29 @@
+defmodule LolAnalytics.Dimensions.Champion.ChampionRepo do
+  alias LoLAnalytics.Repo
+  alias LolAnalytics.Dimensions.Champion.ChampionSchema
+
+  @spec get_or_create(String.t()) :: struct()
+  def get_or_create(champion_id) do
+    champion = Repo.get_by(ChampionSchema, champion_id: champion_id)
+
+    case champion do
+      nil ->
+        changeset = ChampionSchema.changeset(%ChampionSchema{}, %{champion_id: champion_id})
+        Repo.insert(changeset)
+
+      champion ->
+        champion
+    end
+  end
+
+  def update(champion_id, attrs) do
+    get_or_create(champion_id)
+    |> ChampionSchema.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @spec list_champions() :: any()
+  def list_champions() do
+    Repo.all(ChampionSchema)
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/champion/champion_schema.ex

@@ -0,0 +1,17 @@
+defmodule LolAnalytics.Dimensions.Champion.ChampionSchema do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "dim_champion" do
+    field :champion_id, :integer
+    field :name, :string
+    field :image, :string
+    timestamps()
+  end
+
+  def changeset(champion = %__MODULE__{}, attrs \\ %{}) do
+    champion
+    |> cast(attrs, [:champion_id, :name, :image])
+    |> validate_required([:champion_id])
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/item/item_repo.ex

@@ -0,0 +1,21 @@
+defmodule LolAnalytics.Dimensions.Item.ItemRepo do
+  alias LolAnalytics.Dimensions.Item.ItemSchema
+  alias LoLAnalytics.Repo
+
+  def get_or_create(item_id) do
+    item = Repo.get(ItemSchema, item_id: item_id)
+
+    case item do
+      nil ->
+        item_changeset = ItemSchema.changeset(%ItemSchema{}, %{item_id: item_id})
+        Repo.insert(item_changeset)
+
+      item ->
+        item
+    end
+  end
+
+  def list_items() do
+    Repo.all(ItemSchema)
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/item/item_schema.ex

@@ -0,0 +1,15 @@
+defmodule LolAnalytics.Dimensions.Item.ItemSchema do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "dim_item" do
+    field :item_id, :integer
+    timestamps()
+  end
+
+  def changeset(item = %__MODULE__{}, attrs \\ %{}) do
+    item
+    |> cast(attrs, [:item_id])
+    |> validate_required([:item_id])
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/match/match_repo.ex

@@ -0,0 +1,30 @@
+defmodule LolAnalytics.Dimensions.Match.MatchRepo do
+  alias LolAnalytics.Dimensions.Match.MatchSchema
+  alias LoLAnalytics.Repo
+
+  import Ecto.Query
+
+  @spec get_or_create(String.t()) :: %MatchSchema{}
+  def get_or_create(match_id) do
+    query = from m in MatchSchema, where: m.match_id == ^match_id
+    match = Repo.one(query)
+
+    case match do
+      nil ->
+        match_changeset =
+          MatchSchema.changeset(
+            %MatchSchema{},
+            %{match_id: match_id}
+          )
+
+        Repo.insert(match_changeset)
+
+      match ->
+        match
+    end
+  end
+
+  def list_matches() do
+    Repo.all(MatchSchema)
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/match/match_schema.ex

@@ -0,0 +1,15 @@
+defmodule LolAnalytics.Dimensions.Match.MatchSchema do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "dim_match" do
+    field :match_id, :string
+    timestamps()
+  end
+
+  def changeset(match = %__MODULE__{}, attrs \\ %{}) do
+    match
+    |> cast(attrs, [:match_id])
+    |> validate_required([:match_id])
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/patch/patch_repo.ex

@@ -0,0 +1,26 @@
+defmodule LolAnalytics.Dimensions.Patch.PatchRepo do
+  alias LolAnalytics.Dimensions.Patch.PatchSchema
+  alias LoLAnalytics.Repo
+
+  def get_or_create(patch_number) do
+    patch = Repo.get(PatchSchema, patch_number: patch_number)
+
+    case patch do
+      nil ->
+        patch_changeset =
+          PatchSchema.changeset(
+            %PatchSchema{},
+            %{patch_number: patch_number}
+          )
+
+        Repo.insert(patch_changeset)
+
+      patch ->
+        patch
+    end
+  end
+
+  def list_patches() do
+    Repo.all(PatchSchema)
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/patch/patch_schema.ex

@@ -0,0 +1,15 @@
+defmodule LolAnalytics.Dimensions.Patch.PatchSchema do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "dim_patch" do
+    field :patch_number, :string
+    timestamps()
+  end
+
+  def changeset(patch = %__MODULE__{}, attrs \\ %{}) do
+    patch
+    |> cast(attrs, [:patch_number])
+    |> validate_required([:patch_number])
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/player/player_repo.ex

@@ -0,0 +1,28 @@
+defmodule LolAnalytics.Dimensions.Player.PlayerRepo do
+  import Ecto.Query
+
+  alias LolAnalytics.Dimensions.Player.PlayerSchema
+  alias LoLAnalytics.Repo
+
+  def get_or_create(puuid) do
+    query = from p in PlayerSchema, where: p.puuid == ^puuid
+    player = Repo.one(query)
+
+    case player do
+      nil ->
+        player_changeset =
+          PlayerSchema.changeset(
+            %PlayerSchema{},
+            %{puuid: puuid}
+          )
+        Repo.insert(player_changeset)
+
+      player ->
+        player
+    end
+  end
+
+  def list_players() do
+    Repo.all(PlayerSchema)
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/player/player_schema.ex

@@ -0,0 +1,15 @@
+defmodule LolAnalytics.Dimensions.Player.PlayerSchema do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "dim_player" do
+    field :puuid, :string
+    timestamps()
+  end
+
+  def changeset(player = %__MODULE__{}, attrs \\ %{}) do
+    player
+    |> cast(attrs, [:puuid])
+    |> validate_required([:puuid])
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/summoner_spell/summoner_spell_metadata.ex

@@ -0,0 +1,22 @@
+defmodule LolAnalytics.Dimensions.SummonerSpell.SummonerSpellMetadata do
+  alias LolAnalytics.Dimensions.SummonerSpell.SummonerSpellRepo
+  @spells_url "https://ddragon.leagueoflegends.com/cdn/14.11.1/data/en_US/summoner.json"
+
+  def update_metadata() do
+    get_spells()
+    |> Enum.each(&save_metadata/1)
+  end
+
+  defp get_spells() do
+    case HTTPoison.get(@spells_url) do
+      {:ok, resp} ->
+        Poison.decode!(resp.body)["data"]
+    end
+  end
+
+  defp save_metadata({name, metadata}) do
+    %{"key" => spell_id} = metadata
+
+    SummonerSpellRepo.update(spell_id, %{metadata: metadata})
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/summoner_spell/summoner_spell_repo.ex

@@ -0,0 +1,37 @@
+defmodule LolAnalytics.Dimensions.SummonerSpell.SummonerSpellRepo do
+  import Ecto.Query
+
+  alias LolAnalytics.Dimensions.SummonerSpell.SummonerSpellSchema
+  alias LoLAnalytics.Repo
+
+  @spec get_or_create(String.t()) :: any()
+  def get_or_create(spell_id) do
+    query = from s in SummonerSpellSchema, where: s.spell_id == ^spell_id
+    spell = Repo.one(query)
+
+    case spell do
+      nil ->
+        spell_changeset =
+          SummonerSpellSchema.changeset(
+            %SummonerSpellSchema{},
+            %{spell_id: spell_id}
+          )
+
+        Repo.insert(spell_changeset)
+
+      spell ->
+        spell
+    end
+  end
+
+  @spec update(spell_id :: String.t(), attrs :: map()) :: any()
+  def update(spell_id, attrs) do
+    get_or_create(spell_id)
+    |> SummonerSpellSchema.changeset(attrs)
+    |> Repo.update()
+  end
+
+  def list_spells() do
+    Repo.all(SummonerSpellSchema)
+  end
+end

apps/lol_analytics/lib/lol_analytics/dimensions/summoner_spell/summoner_spell_schema.ex

@@ -0,0 +1,16 @@
+defmodule LolAnalytics.Dimensions.SummonerSpell.SummonerSpellSchema do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "dim_summoner_spell" do
+    field :spell_id, :integer
+    field :metadata, :map
+    timestamps()
+  end
+
+  def changeset(summoner_spell = %__MODULE__{}, attrs) do
+    summoner_spell
+    |> cast(attrs, [:spell_id, :metadata])
+    |> validate_required([:spell_id])
+  end
+end

apps/lol_analytics/lib/lol_analytics/facts/champion_picked_summoner_spell/fact_processor.ex

@@ -0,0 +1,52 @@
+defmodule LolAnalytics.Facts.ChampionPickedSummonerSpell.FactProcessor do
+alias LolAnalytics.Facts.ChampionPickedSummonerSpell
+
+  def process_game_at_url(url) do
+    data = HTTPoison.get!(url)
+    process_game_data(data.body)
+  end
+
+  defp process_game_data(data) do
+    decoded_match = Poison.decode!(data, as: %LoLAPI.Model.MatchResponse{})
+    participants = decoded_match.info.participants
+    version = extract_game_version(decoded_match)
+
+    participants
+    |> Enum.each(fn participant = %LoLAPI.Model.Participant{} ->
+      if participant.teamPosition != "" do
+
+        attrs_spell_1 = %{
+          champion_id: participant.championId,
+          match_id: decoded_match.metadata.matchId,
+          is_win: participant.win,
+          summoner_spell_id: participant.summoner1Id,
+          game_length_seconds: decoded_match.info.gameDuration,
+          queue_id: decoded_match.info.queueId,
+          puuid: participant.puuid,
+          team_position: participant.teamPosition,
+          patch_number: version
+        }
+        attrs_spell_2 = %{
+          champion_id: participant.championId,
+          match_id: decoded_match.metadata.matchId,
+          is_win: participant.win,
+          summoner_spell_id: participant.summoner2Id,
+          game_length_seconds: decoded_match.info.gameDuration,
+          queue_id: decoded_match.info.queueId,
+          puuid: participant.puuid,
+          team_position: participant.teamPosition,
+          patch_number: version
+        }
+        ChampionPickedSummonerSpell.Repo.insert(attrs_spell_1)
+        ChampionPickedSummonerSpell.Repo.insert(attrs_spell_2)
+      end
+    end)
+  end
+
+  defp extract_game_version(game_data) do
+    game_data.info.gameVersion
+    |> String.split(".")
+    |> Enum.take(2)
+    |> Enum.join(".")
+  end
+end

apps/lol_analytics/lib/lol_analytics/facts/champion_picked_summoner_spell/repo.ex

@@ -0,0 +1,89 @@
+defmodule LolAnalytics.Facts.ChampionPickedSummonerSpell.Repo do
+  import Ecto.Query
+
+  alias LolAnalytics.Dimensions.SummonerSpell.SummonerSpellSchema
+  alias LolAnalytics.Dimensions.SummonerSpell.SummonerSpellRepo
+  alias LolAnalytics.Dimensions.Champion.ChampionSchema
+
+  alias LolAnalytics.Facts.ChampionPickedSummonerSpell.Schema
+
+  alias LolAnalytics.Dimensions.Player.PlayerRepo
+  alias LolAnalytics.Dimensions.Champion.ChampionRepo
+  alias LolAnalytics.Dimensions.Match.MatchRepo
+
+  alias LoLAnalytics.Repo
+
+  @type insert_attrs :: %{
+          match_id: String.t(),
+          champion_id: String.t(),
+          puuid: String.t(),
+          summoner_spell_id: :integer
+        }
+
+  @spec insert(insert_attrs()) :: any()
+  def insert(attrs) do
+    _match = MatchRepo.get_or_create(attrs.match_id)
+    _champion = ChampionRepo.get_or_create(attrs.champion_id)
+    _player = PlayerRepo.get_or_create(attrs.puuid)
+    _spell = SummonerSpellRepo.get_or_create(attrs.summoner_spell_id)
+
+    prev =
+      from(f in Schema,
+        where:
+          f.match_id == ^attrs.match_id and
+            f.champion_id == ^attrs.champion_id and
+            f.summoner_spell_id ==
+              ^attrs.summoner_spell_id
+      )
+      |> Repo.one()
+
+    changeset = Schema.changeset(prev || %Schema{}, attrs)
+
+    IO.inspect(attrs)
+
+    Repo.insert_or_update(changeset)
+    |> IO.inspect()
+  end
+
+  def get_champion_picked_summoners(championId, team_position \\ "MIDDLE") do
+    query =
+      from f in Schema,
+        where: f.champion_id == ^championId and f.team_position == ^team_position,
+        join: c in ChampionSchema,
+        on: c.champion_id == f.champion_id,
+        join: s in SummonerSpellSchema,
+        on: s.spell_id == f.summoner_spell_id,
+        select: %{
+          wins: fragment("count(CASE WHEN ? THEN 1 END)", f.is_win),
+          win_rate:
+            fragment(
+              "
+              ((cast(count(CASE WHEN ? THEN 1 END) as float) / cast(count(*) as float)) * 100.0
+              )",
+              f.is_win
+            ),
+          id: f.champion_id,
+          spell_id: f.summoner_spell_id,
+          metadata: s.metadata,
+          champion_name: c.name,
+          champion_id: c.champion_id,
+          team_position: f.team_position,
+          total_games: count("*")
+        },
+        group_by: [
+          f.champion_id,
+          f.summoner_spell_id,
+          s.metadata,
+          c.image,
+          c.name,
+          c.champion_id,
+          f.team_position
+        ]
+
+    Repo.all(query)
+  end
+
+  def list_facts() do
+    Repo.all(Schema)
+  end
+end

apps/lol_analytics/lib/lol_analytics/facts/champion_picked_summoner_spell/schema.ex

@@ -0,0 +1,34 @@
+defmodule LolAnalytics.Facts.ChampionPickedSummonerSpell.Schema do
+  use Ecto.Schema
+
+  import Ecto.Changeset
+
+  @params [
+    :champion_id,
+    :summoner_spell_id,
+    :match_id,
+    :is_win,
+    :game_length_seconds,
+    :queue_id,
+    :team_position,
+    :puuid
+  ]
+
+  schema "fact_champion_picked_summoner_spell" do
+    field :champion_id, :integer
+    field :summoner_spell_id, :integer
+    field :match_id, :string
+    field :is_win, :boolean
+    field :game_length_seconds, :integer
+    field :queue_id, :integer
+    field :team_position, :string
+    field :puuid, :string
+  end
+
+  def changeset(fact = %__MODULE__{}, attrs \\ %{}) do
+    fact
+    |> cast(attrs, @params)
+    |> validate_required(@params)
+    |> unique_constraint([:puuid, :match_id, :summoner_spell_id])
+  end
+end

apps/lol_analytics/lib/lol_analytics/facts/champion_played_game/champion_played_game_repo.ex

@@ -0,0 +1,50 @@
+defmodule LolAnalytics.Facts.ChampionPlayedGame.Repo do
+  import Ecto.Query
+
+  alias LolAnalytics.Dimensions.Champion.ChampionSchema
+  alias LolAnalytics.Dimensions.Player.PlayerRepo
+  alias LolAnalytics.Dimensions.Champion.ChampionRepo
+  alias LolAnalytics.Dimensions.Match.MatchRepo
+  alias LolAnalytics.Facts.ChampionPlayedGame.Schema
+  alias LoLAnalytics.Repo
+
+  def insert(attrs) do
+    _match = MatchRepo.get_or_create(attrs.match_id)
+    _champion = ChampionRepo.get_or_create(attrs.champion_id)
+    _player = PlayerRepo.get_or_create(attrs.puuid)
+    changeset = Schema.changeset(%Schema{}, attrs)
+    Repo.insert(changeset)
+  end
+
+  def list_played_matches() do
+    Repo.all(Schema)
+  end
+
+  def get_win_rates do
+    query =
+      from m in Schema,
+        join: c in ChampionSchema,
+        on: c.champion_id == m.champion_id,
+        select: %{
+          wins: fragment("count(CASE WHEN ? THEN 1 END)", m.is_win),
+          win_rate:
+            fragment(
+              "
+              ((cast(count(CASE WHEN ? THEN 1 END) as float) / cast(count(*) as float)) * 100.0
+              )",
+              m.is_win
+            ),
+          id: m.champion_id,
+          name: c.name,
+          image: c.image,
+          team_position: m.team_position,
+          total_games: count("*")
+        },
+        group_by: [m.champion_id, c.image, c.name, m.team_position]
+
+    Repo.all(query)
+  end
+
+  def get_win_rates_by_roles() do
+  end
+end

apps/lol_analytics/lib/lol_analytics/facts/champion_played_game/champion_played_game_schema.ex

@@ -0,0 +1,33 @@
+defmodule LolAnalytics.Facts.ChampionPlayedGame.Schema do
+  use Ecto.Schema
+
+  import Ecto.Changeset
+
+  @casting_attrs [
+    :champion_id,
+    :match_id,
+    :is_win,
+    :game_length_seconds,
+    :team_position,
+    :puuid,
+    :queue_id
+  ]
+
+  schema "fact_champion_played_game" do
+    field :champion_id, :integer
+    field :match_id, :string
+    field :is_win, :boolean
+    field :game_length_seconds, :integer
+    field :team_position, :string
+    field :puuid, :string
+    field :queue_id, :integer
+    timestamps()
+  end
+
+  def changeset(fact = %__MODULE__{}, attrs \\ %{}) do
+    fact
+    |> cast(attrs, @casting_attrs)
+    |> validate_required(@casting_attrs)
+    |> unique_constraint([:id, :champion_id, :queue_id])
+  end
+end

apps/lol_analytics/lib/lol_analytics/facts/champion_played_game/fact_processor.ex

@@ -0,0 +1,37 @@
+defmodule LolAnalytics.Facts.ChampionPlayedGame.FactProcessor do
+  def process_game_at_url(path) do
+    data = HTTPoison.get!(path)
+    process_game_data(data.body)
+  end
+
+  def process_game_data(data) do
+    decoded_match = Poison.decode!(data, as: %LoLAPI.Model.MatchResponse{})
+    participants = decoded_match.info.participants
+    version = extract_game_version(decoded_match)
+
+    participants
+    |> Enum.each(fn participant = %LoLAPI.Model.Participant{} ->
+      if participant.teamPosition != "" do
+        attrs = %{
+          champion_id: participant.championId,
+          match_id: decoded_match.metadata.matchId,
+          is_win: participant.win,
+          game_length_seconds: decoded_match.info.gameDuration,
+          queue_id: decoded_match.info.queueId,
+          puuid: participant.puuid,
+          team_position: participant.teamPosition,
+          patch_number: version
+        }
+
+        LolAnalytics.Facts.ChampionPlayedGame.Repo.insert(attrs)
+      end
+    end)
+  end
+
+  defp extract_game_version(game_data) do
+    game_data.info.gameVersion
+    |> String.split(".")
+    |> Enum.take(2)
+    |> Enum.join(".")
+  end
+end

apps/lol_analytics/lib/lol_analytics/facts/facts_runner.ex

@@ -0,0 +1,22 @@
+defmodule LolAnalytics.Facts.FactsRunner do
+  alias LolAnalytics.Facts
+
+  def analyze_all_matches do
+    Storage.MatchStorage.S3MatchStorage.stream_files("ranked")
+    |> Enum.each(fn %{key: path} ->
+      get_facts()
+      |> Enum.each(fn fact_runner ->
+        apply(fact_runner, ["http://192.168.1.55:9000/ranked/#{path}"])
+      end)
+    end)
+  end
+
+  def analyze_match() do
+  end
+
+  def get_facts() do
+    [
+      &Facts.ChampionPickedSummonerSpell.FactProcessor.process_game_at_url/1
+    ]
+  end
+end

apps/lol_analytics/lib/lol_analytics/match/match_repo.ex

@@ -13,7 +13,7 @@ defmodule LolAnalytics.Match.MatchRepo do
     LoLAnalytics.Repo.one(query)
   end
 
-  @spec get_match(String.t()) :: %LolAnalytics.Match.MatchSchema{}
+  @spec get_match(String.t()) :: %LolAnalytics.Match.MatchSchema{} | nil
   def get_match(match_id) do
     query = from m in MatchSchema, where: m.match_id == ^match_id
 

apps/lol_analytics/mix.exs

@@ -42,6 +42,7 @@ defmodule LoLAnalytics.MixProject do
       {:postgrex, ">= 0.0.0"},
       {:jason, "~> 1.2"},
       {:lol_api, in_umbrella: true},
+      {:storage, in_umbrella: true},
       {:httpoison, "~> 2.2"},
       {:poison, "~> 5.0"}
     ]

apps/lol_analytics/priv/repo/migrations/20240526160430_analytics_tables.exs

@@ -0,0 +1,62 @@
+defmodule LoLAnalytics.Repo.Migrations.AnalyticsTables do
+  use Ecto.Migration
+
+  def change do
+    create table("dim_champion") do
+      add :champion_id, :integer, primary_key: true, null: false
+      timestamps()
+    end
+
+    create index("dim_champion", [:champion_id], unique: true)
+
+    create table("dim_item") do
+      add :item_id, :integer, primary_key: true, null: false
+      timestamps()
+    end
+
+    create index("dim_item", [:item_id], unique: true)
+
+    create table("dim_match") do
+      add :match_id, :string, primary_key: true, null: false
+      timestamps()
+    end
+
+    create index("dim_match", [:match_id], unique: true)
+
+    create table("dim_patch") do
+      add :patch_number, :string, primary_key: true, null: false
+      timestamps()
+    end
+
+    create index("dim_patch", [:patch_number], unique: true)
+
+    create table("dim_player") do
+      add :puuid, :string, primary_key: true, null: false
+      timestamps()
+    end
+
+    create index("dim_player", [:puuid], unique: true)
+
+    create table("dim_summoner_spell") do
+      add :spell_id, :integer, primary_key: true, null: false
+      timestamps()
+    end
+
+    create index("dim_summoner_spell", [:spell_id], unique: true)
+
+    create table("fact_champion_played_game") do
+      add :champion_id, references("dim_champion", column: :champion_id, type: :integer)
+      add :match_id, references("dim_match", column: :match_id, type: :string)
+      add :is_win, :boolean
+      add :game_length_seconds, :integer
+      add :queue_id, :integer
+      add :patch_number, references("dim_patch", column: :patch_number, type: :string)
+      add :team_position, :string
+      add :puuid, references("dim_player", column: :puuid, type: :string)
+      timestamps()
+    end
+
+    create index("fact_champion_played_game", [:id, :champion_id, :queue_id])
+    create index("fact_champion_played_game", [:puuid, :match_id], unique: true)
+  end
+end

apps/lol_analytics/priv/repo/migrations/20240530194815_champion_dim_name_image.exs

@@ -0,0 +1,10 @@
+defmodule LoLAnalytics.Repo.Migrations.ChampionDimName do
+  use Ecto.Migration
+
+  def change do
+    alter table("dim_champion") do
+      add :name, :string
+      add :image, :string
+    end
+  end
+end

apps/lol_analytics/priv/repo/migrations/20240603091346_summoner_spell_win_rate.exs

@@ -0,0 +1,31 @@
+defmodule LoLAnalytics.Repo.Migrations.SummonerSpellWinRate do
+  use Ecto.Migration
+
+  def change do
+    create table("fact_champion_picked_summoner_spell") do
+      add :champion_id, references("dim_champion", column: :champion_id, type: :integer)
+      add :summoner_spell_id, references("dim_summoner_spell", column: :spell_id, type: :integer)
+      add :match_id, references("dim_match", column: :match_id, type: :string)
+      add :is_win, :boolean
+      add :game_length_seconds, :integer
+      add :queue_id, :integer
+      add :team_position, :string
+      add :puuid, references("dim_player", column: :puuid, type: :string)
+      add :patch_number, references("dim_patch", column: :patch_number, type: :string)
+    end
+
+    create index(
+             "fact_champion_picked_summoner_spell",
+             [:puuid, :match_id, :summoner_spell_id],
+             unique: true
+           )
+
+    create index("fact_champion_picked_summoner_spell", [
+             :is_win,
+             :team_position,
+             :queue_id,
+             :summoner_spell_id,
+             :patch_number
+           ])
+  end
+end

apps/lol_analytics/priv/repo/migrations/20240606222334_summoner_spell_metadata.exs

@@ -0,0 +1,9 @@
+defmodule LoLAnalytics.Repo.Migrations.SummonerSpellMetadata do
+  use Ecto.Migration
+
+  def change do
+    alter table("dim_summoner_spell") do
+      add :metadata, :map
+    end
+  end
+end

apps/lol_analytics/priv/repo/migrations/20240606222701_summoner_spell_metadata_index.exs

@@ -0,0 +1,11 @@
+defmodule LoLAnalytics.Repo.Migrations.SummonerSpellMetadataIndex do
+  use Ecto.Migration
+
+  def up do
+    execute("CREATE INDEX dim_summoner_spell_metadata ON dim_summoner_spell USING GIN(metadata)")
+  end
+
+  def down do
+    execute("DROP INDEX dim_summoner_spell_metadata")
+  end
+end

apps/lol_analytics_web/lib/lol_analytics_web/components/champion_components/champion_avatar.ex

@@ -0,0 +1,16 @@
+defmodule LolAnalyticsWeb.ChampionComponents.ChampionAvatar do
+  use Phoenix.Component
+
+  attr :id, :integer, required: true
+  attr :image, :string, required: true
+  attr :name, :string, required: true
+
+  def champion_avatar(assigns) do
+    ~H"""
+    <div class="flex flex-col w-40">
+      <img src={@image} alt="champion-icon" />
+      <p class="w-full text-center"><%= @name %></p>
+    </div>
+    """
+  end
+end

apps/lol_analytics_web/lib/lol_analytics_web/components/champion_components/champion_card.ex

@@ -0,0 +1,33 @@
+defmodule LolAnalyticsWeb.ChampionComponents.ChampionCard.Props do
+  defstruct [:id, :win_rate, :image, :name, :team_position, :wins, :total_games]
+end
+
+defmodule LolAnalyticsWeb.ChampionComponents.ChampionCard do
+  use Phoenix.Component
+
+  alias LolAnalyticsWeb.ChampionComponents.ChampionCard.Props
+
+  attr :props, Props, default: %Props{}
+
+  def champion_card(assigns) do
+    ~H"""
+    <.link patch={"/champions/#{@props.id}"}>
+      <div class="flex flex-col rounded-xl bg-clip-border overflow-hidden bg-gray-200">
+        <img src={"https://ddragon.leagueoflegends.com/cdn/14.11.1/img/champion/#{@props.image}"} />
+        <div class="py-2" />
+        <div class="flex mx-auto">
+          <img src={team_position_image(@props.team_position)} class="w-5 h-5" />
+          <h3><%= @props.name %></h3>
+        </div>
+        <div class="py-2" />
+      </div>
+    </.link>
+    """
+  end
+
+  defp team_position_image("BOTTOM"), do: "/images/lanes/bot.png"
+  defp team_position_image("MIDDLE"), do: "/images/lanes/mid.png"
+  defp team_position_image("TOP"), do: "/images/lanes/top.png"
+  defp team_position_image("JUNGLE"), do: "/images/lanes/jungle.png"
+  defp team_position_image("UTILITY"), do: "/images/lanes/utility.png"
+end

apps/lol_analytics_web/lib/lol_analytics_web/components/champion_components/summoner_spell.ex

@@ -0,0 +1,42 @@
+defmodule LolAnalyticsWeb.ChampionComponents.SummonerSpells.Props.SummonerSpell do
+  defstruct [:id, :name, :win_rate, :wins, :total_games, :image]
+
+  @type t :: %{
+          id: integer(),
+          win_rate: float(),
+          wins: integer(),
+          total_games: integer(),
+          image: String.t(),
+          name: String.t()
+        }
+end
+
+defmodule LolAnalyticsWeb.ChampionComponents.SummonerSpells.Props do
+  alias LolAnalyticsWeb.ChampionComponents.SummonerSpells.Props.SummonerSpell
+
+  defstruct spell: %SummonerSpell{}
+
+  @type t :: %{spell: SummonerSpell.t()}
+end
+
+defmodule LolAnalyticsWeb.ChampionComponents.SummonerSpell do
+  alias LolAnalyticsWeb.ChampionComponents.SummonerSpells.Props
+  use Phoenix.Component
+
+  attr :spells, Props, default: %Props{}
+
+  def summoner_spells(assigns) do
+    ~H"""
+    <div class="flex flex-wrap flex-wrap gap-4">
+      <%= for spell <- assigns.spells.summoner_spells do %>
+        <div clas="flex flex-col gap-1">
+          <img src={spell.spell.image} />
+          <p><%= spell.spell.name %></p>
+          <p><%= spell.spell.win_rate %>%</p>
+          <p><%= spell.spell.wins %>/<%= spell.spell.total_games %></p>
+        </div>
+      <% end %>
+    </div>
+    """
+  end
+end

apps/lol_analytics_web/lib/lol_analytics_web/components/core_components.ex

@@ -302,6 +302,9 @@ defmodule LoLAnalyticsWeb.CoreComponents do
   end
 
   def input(%{type: "checkbox"} = assigns) do
+    IO.puts(">>>>")
+    IO.inspect(assigns)
+
     assigns =
       assign_new(assigns, :checked, fn ->
         Phoenix.HTML.Form.normalize_value("checkbox", assigns[:value])
@@ -315,8 +318,8 @@ defmodule LoLAnalyticsWeb.CoreComponents do
           type="checkbox"
           id={@id}
           name={@name}
-          value="true"
-          checked={@checked}
+          value="false"
+          checked={false}
           class="rounded border-zinc-300 text-zinc-900 focus:ring-0"
           {@rest}
         />

apps/lol_analytics_web/lib/lol_analytics_web/components/layouts/app.html.heex

@@ -2,25 +2,16 @@
   <div class="flex items-center justify-between border-b border-zinc-100 py-3 text-sm">
     <div class="flex items-center gap-4">
       <a href="/">
-        <img src={~p"/images/logo.svg"} width="36" />
+        LoL Analytics
       </a>
       <p class="bg-brand/5 text-brand rounded-full px-2 font-medium leading-6">
         v<%= Application.spec(:phoenix, :vsn) %>
       </p>
     </div>
     <div class="flex items-center gap-4 font-semibold leading-6 text-zinc-900">
-      <a href="https://twitter.com/elixirphoenix" class="hover:text-zinc-700">
-        @elixirphoenix
-      </a>
-      <a href="https://github.com/phoenixframework/phoenix" class="hover:text-zinc-700">
-        GitHub
-      </a>
-      <a
-        href="https://hexdocs.pm/phoenix/overview.html"
-        class="rounded-lg bg-zinc-100 px-2 py-1 hover:bg-zinc-200/80"
-      >
-        Get Started <span aria-hidden="true">&rarr;</span>
-      </a>
+      <.link patch="/champions">
+        Champions
+      </.link>
     </div>
   </div>
 </header>

apps/lol_analytics_web/lib/lol_analytics_web/components/layouts/root.html.heex

@@ -1,17 +1,20 @@
 <!DOCTYPE html>
 <html lang="en" class="[scrollbar-gutter:stable]">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta name="csrf-token" content={get_csrf_token()} />
-    <.live_title suffix=" · Phoenix Framework">
-      <%= assigns[:page_title] || "LoLAnalytics" %>
-    </.live_title>
-    <link phx-track-static rel="stylesheet" href={~p"/assets/app.css"} />
-    <script defer phx-track-static type="text/javascript" src={~p"/assets/app.js"}>
-    </script>
-  </head>
-  <body class="bg-white antialiased">
-    <%= @inner_content %>
-  </body>
+
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="csrf-token" content={get_csrf_token()} />
+  <.live_title suffix=" · Phoenix Framework">
+    <%= assigns[:page_title] || "LoLAnalytics" %>
+  </.live_title>
+  <link phx-track-static rel="stylesheet" href={~p"/assets/app.css"} />
+  <script defer phx-track-static type="text/javascript" src={~p"/assets/app.js"}>
+  </script>
+</head>
+
+<body class="bg-white antialiased">
+  <%= @inner_content %>
+</body>
+
 </html>

apps/lol_analytics_web/lib/lol_analytics_web/live/champion_live/champion.ex

@@ -0,0 +1,3 @@
+defmodule LolAnalyticsWeb.ChampionLive.ChampionSummary do
+  defstruct [:id, :win_rate, :image, :name, :team_position, :wins, :total_games]
+end

apps/lol_analytics_web/lib/lol_analytics_web/live/champion_live/components/champion_filters.ex

@@ -0,0 +1,93 @@
+defmodule LolAnalyticsWeb.ChampionLive.Components.ChampionFilters do
+  use LoLAnalyticsWeb, :live_component
+
+  @roles_definition [
+    %{title: "All", value: "all"},
+    %{title: "Top", value: "TOP"},
+    %{title: "Jungle", value: "JUNGLE"},
+    %{title: "Mid", value: "MIDDLE"},
+    %{title: "Bot", value: "BOTTOM"},
+    %{title: "Support", value: "UTILITY"}
+  ]
+
+  def on_role_selected(role) do
+    send_update(LolAnalyticsWeb.ChampionLive, role)
+  end
+
+  def mount(socket) do
+    socket =
+      assign(socket, :roles, @roles_definition)
+      |> assign(:form, build_roles_form())
+
+    {:ok, socket}
+  end
+
+  defp build_roles() do
+    @roles_definition
+    |> Enum.reduce(%{}, fn role, acc ->
+      Map.merge(acc, %{"#{role.value}" => false})
+    end)
+    |> Map.merge(%{"all" => true})
+  end
+
+  defp build_roles_form() do
+    @roles_definition
+    |> Enum.reduce(%{}, fn role, acc ->
+      Map.merge(acc, %{"#{role.value}" => false})
+    end)
+    |> Map.merge(%{"all" => true})
+    |> to_form
+  end
+
+  def handle_event("filter", unsigned_params, socket) do
+    # updated_form =
+    #   unsigned_params
+    #   |> Enum.map(fn {key, val} -> {key, key == unsigned_params["_target"]} end)
+
+    IO.inspect(unsigned_params)
+    # # assign()
+    # {:noreply, socket |> assign(:form, to_form(updated_form))}
+  end
+
+  attr :selectedrole, :string, required: true
+  attr :roles, :list, default: []
+
+  def render(assigns) do
+    IO.puts(">>>>1")
+    # IO.inspect(assigns)
+    IO.inspect(assigns.selectedrole)
+    IO.inspect(">>>>>2")
+
+    selected_class =
+      "px-8 py-2 flex flex-row gap-2 align-middle rounded-md border-gray-200 border border-sky-500"
+
+    ~H"""
+    <div>
+      <div class="flex flex-row justify-between p-10">
+        <%= for role <- @roles do %>
+          <%!-- <%= IO.inspect(role) %> --%>
+          <%= if (assigns.selectedrole == role.value) do %>
+            <div phx-click="filter" phx-value-role={role.title} class={selected_class}>
+              <%!-- <.input enabled={false} type="checkbox" field={@form[role.value]} /> --%>
+              <p><%= role.title %></p>
+            </div>
+          <% else %>
+            <div
+              phx-click="filter"
+              phx-value-role={role.value}
+              class="px-8 py-2 flex flex-row gap-2 align-middle"
+            >
+              <%!-- <.input enabled={false} type="checkbox" field={@form[role.value]} /> --%>
+              <p><%= role.title %></p>
+            </div>
+          <% end %>
+        <% end %>
+      </div>
+    </div>
+    """
+  end
+end
+
+defmodule LolAnalyticsWeb.ChampionLive.Components.ChampionFilters.EventHandler do
+  @callback role_selected() :: none()
+end

apps/lol_analytics_web/lib/lol_analytics_web/live/champion_live/index.ex

@@ -0,0 +1,75 @@
+defmodule LoLAnalyticsWeb.ChampionLive.Index do
+  use LoLAnalyticsWeb, :live_view
+
+  import LolAnalyticsWeb.ChampionComponents.ChampionCard
+
+  alias LolAnalyticsWeb.ChampionLive.Mapper
+  alias LolAnalyticsWeb.ChampionLive.Components.ChampionFilters
+
+  @behaviour LolAnalyticsWeb.ChampionFilters.EventHandler
+
+  @roles [
+    %{title: "All", value: "all"},
+    %{title: "Top", value: "TOP"},
+    %{title: "Jungle", value: "JUNGLE"},
+    %{title: "Mid", value: "MIDDLE"},
+    %{title: "Bot", value: "BOTTOM"},
+    %{title: "Support", value: "UTILITY"}
+  ]
+
+  @impl true
+  def mount(_params, _session, socket) do
+    champs = LolAnalytics.Facts.ChampionPlayedGame.Repo.get_win_rates()
+
+    mapped =
+      champs
+      |> Mapper.map_champs()
+      |> Enum.sort(&(&1.win_rate >= &2.win_rate))
+
+    socket =
+      socket
+      |> stream(:champions, mapped)
+      |> assign(:selected_role, "all")
+
+    {:ok, socket}
+  end
+
+  @impl true
+  def handle_event("filter", %{"role" => selected_role} = params, socket) do
+    champs =
+      LolAnalytics.Facts.ChampionPlayedGame.Repo.get_win_rates()
+      |> filter_champs(selected_role)
+
+    {:noreply,
+     socket
+     |> stream(:champions, champs)
+     |> assign(:selected_role, selected_role)}
+  end
+
+  def handle_event("filter_champs", params, socket) do
+  end
+
+  defp filter_champs(champs, selected_role) do
+    champs =
+      LolAnalytics.Facts.ChampionPlayedGame.Repo.get_win_rates()
+      |> Enum.filter((&filter_role/1).(selected_role))
+      |> Mapper.map_champs()
+      |> Enum.sort(&(&1.win_rate >= &2.win_rate))
+  end
+
+  defp filter_role(role) do
+    fn champ ->
+      champ.team_position == role || role == "all"
+    end
+  end
+
+  @impl true
+  def handle_params(params, _url, socket) do
+    {:noreply, apply_action(socket, socket.assigns.live_action, params)}
+  end
+
+  defp apply_action(socket, :index, _params) do
+    socket
+    |> assign(:page_title, "Listing Champions")
+  end
+end

apps/lol_analytics_web/lib/lol_analytics_web/live/champion_live/index.html.heex

@@ -0,0 +1,20 @@
+<.header>
+  Champions
+</.header>
+
+<h1>Filters</h1>
+
+
+<.live_component module={ChampionFilters} id="role-filters" selectedrole={@selected_role} />
+
+
+<div id="champions" class="grid grid-cols-4 gap-4">
+  <%= for {_, champion} <- @streams.champions do %>
+    <.champion_card props={champion} />
+    <% end %>
+</div>
+
+<.modal :if={@live_action in [:new, :edit]} id="champion-modal" show on_cancel={JS.patch(~p"/champions")}>
+  <.live_component module={LoLAnalyticsWeb.ChampionLive.FormComponent} id={@champion.champion_id || :new}
+    title={@page_title} action={@live_action} champion={@champion} patch={~p"/champions"} />
+</.modal>

apps/lol_analytics_web/lib/lol_analytics_web/live/champion_live/mapper.ex

@@ -0,0 +1,13 @@
+defmodule LolAnalyticsWeb.ChampionLive.Mapper do
+  alias LolAnalyticsWeb.ChampionLive.ChampionSummary
+
+  def map_champs(champs) do
+    champs
+    |> Enum.map(fn champ ->
+      %{
+        champ
+        | win_rate: :erlang.float_to_binary(champ.win_rate, decimals: 2)
+      }
+    end)
+  end
+end

apps/lol_analytics_web/lib/lol_analytics_web/live/champion_live/show.ex

@@ -0,0 +1,39 @@
+defmodule LoLAnalyticsWeb.ChampionLive.Show do
+  use LoLAnalyticsWeb, :live_view
+
+  import LolAnalyticsWeb.ChampionComponents.SummonerSpell
+  import LolAnalyticsWeb.ChampionComponents.ChampionAvatar
+
+  alias LolAnalyticsWeb.ChampionComponents.SummonerSpells.ShowMapper
+
+  @impl true
+  def mount(_params, _session, socket) do
+    {:ok, socket}
+  end
+
+  @impl true
+  def handle_params(%{"id" => id}, _, socket) do
+    {:noreply,
+     socket
+     |> assign(:page_title, page_title(socket.assigns.live_action))
+     |> assign(:champion, load_champion_info(id) |> ShowMapper.map_champion())
+     |> assign(:summoner_spells, %{
+       summoner_spells: load_summoner_spells(id) |> ShowMapper.map_spells()
+     })}
+  end
+
+  defp load_summoner_spells(champion_id) do
+    LolAnalytics.Facts.ChampionPickedSummonerSpell.Repo.get_champion_picked_summoners(champion_id)
+  end
+
+  defp load_champion_info(champion_id) do
+    champion = LolAnalytics.Dimensions.Champion.ChampionRepo.get_or_create(champion_id)
+
+    IO.inspect(champion)
+
+    champion
+  end
+
+  defp page_title(:show), do: "Show Champion"
+  defp page_title(:edit), do: "Edit Champion"
+end

apps/lol_analytics_web/lib/lol_analytics_web/live/champion_live/show.html.heex

@@ -0,0 +1,15 @@
+<.header>
+  Champion <%= @champion.id %>
+    <:actions></:actions>
+</.header>
+
+<.champion_avatar id={@champion.id} name={@champion.name}
+  image={"https://ddragon.leagueoflegends.com/cdn/14.11.1/img/champion/#{@champion.image}"} />
+
+<div class="my-4" />
+
+<.summoner_spells spells={@summoner_spells} />
+
+<.back navigate={~p"/champions"}>
+  Back to champions
+</.back>

apps/lol_analytics_web/lib/lol_analytics_web/live/champion_live/show_mapper.ex

@@ -0,0 +1,33 @@
+defmodule LolAnalyticsWeb.ChampionComponents.SummonerSpells.ShowMapper do
+  alias LolAnalyticsWeb.ChampionComponents.SummonerSpells.SummonerSpell
+
+  @spec map_champion(%LolAnalytics.Dimensions.Champion.ChampionSchema{}) :: map()
+  def map_champion(champion) do
+    %{
+      id: champion.champion_id,
+      name: champion.name,
+      image: champion.image
+    }
+  end
+
+  def map_spells(items) do
+    items
+    |> Enum.map(&map_spell/1)
+    |> Enum.sort(&(&1.spell.total_games > &2.spell.total_games))
+  end
+
+  def map_spell(spell) do
+    image = spell.metadata["image"]["full"]
+
+    %LolAnalyticsWeb.ChampionComponents.SummonerSpells.Props{
+      spell: %LolAnalyticsWeb.ChampionComponents.SummonerSpells.Props.SummonerSpell{
+        id: spell.id,
+        win_rate: :erlang.float_to_binary(spell.win_rate, decimals: 2),
+        total_games: spell.total_games,
+        image: "https://ddragon.leagueoflegends.com/cdn/14.11.1/img/spell/#{image}",
+        name: spell.metadata["name"],
+        wins: spell.wins
+      }
+    }
+  end
+end

apps/lol_analytics_web/lib/lol_analytics_web/live/role_live/form_component.ex

@@ -0,0 +1,27 @@
+defmodule LoLAnalyticsWeb.RoleLive.FormComponent do
+  use LoLAnalyticsWeb, :live_component
+
+  @impl true
+  def render(assigns) do
+    ~H"""
+    <div>
+      <.header>
+        <%= @title %>
+        <:subtitle>Use this form to manage role records in your database.</:subtitle>
+      </.header>
+
+      <.simple_form
+        for={@form}
+        id="role-form"
+        phx-target={@myself}
+        phx-change="validate"
+        phx-submit="save"
+      >
+        <:actions>
+          <.button phx-disable-with="Saving...">Save Role</.button>
+        </:actions>
+      </.simple_form>
+    </div>
+    """
+  end
+end

apps/lol_analytics_web/lib/lol_analytics_web/live/role_live/index.ex

@@ -0,0 +1,34 @@
+defmodule LoLAnalyticsWeb.RoleLive.Index do
+  use LoLAnalyticsWeb, :live_view
+
+  @roles ["ALL", "TOP", "MIDDLE", "JUNGLE", "UTILITY", "BOTTOM"]
+
+  @impl true
+  def mount(_params, _session, socket) do
+    {:ok, stream(socket, :roles, @roles)}
+  end
+
+  @impl true
+  def handle_params(params, _url, socket) do
+    {:noreply, apply_action(socket, socket.assigns.live_action, params)}
+  end
+
+  defp apply_action(socket, :index, _params) do
+    socket
+    |> assign(:page_title, "Listing Roles")
+    |> assign(:role, nil)
+  end
+
+  @impl true
+  def handle_info({LoLAnalyticsWeb.RoleLive.FormComponent, {:saved, role}}, socket) do
+    {:noreply, stream_insert(socket, :roles, role)}
+  end
+
+  # @impl true
+  # def handle_event("delete", %{"id" => id}, socket) do
+  #   role = Accounts.get_role!(id)
+  #   {:ok, _} = Accounts.delete_role(role)
+
+  #   {:noreply, stream_delete(socket, :roles, role)}
+  # end
+end

apps/lol_analytics_web/lib/lol_analytics_web/live/role_live/index.html.heex

@@ -0,0 +1,4 @@
+<.header>
+  Listing Roles
+  <:actions></:actions>
+</.header>

apps/lol_analytics_web/lib/lol_analytics_web/live/role_live/show.ex

@@ -0,0 +1,18 @@
+defmodule LoLAnalyticsWeb.RoleLive.Show do
+  use LoLAnalyticsWeb, :live_view
+
+  @impl true
+  def mount(_params, _session, socket) do
+    {:ok, socket}
+  end
+
+  @impl true
+  def handle_params(%{"id" => _id}, _, socket) do
+    {:noreply,
+     socket
+     |> assign(:page_title, page_title(socket.assigns.live_action))}
+  end
+
+  defp page_title(:show), do: "Show Role"
+  defp page_title(:edit), do: "Edit Role"
+end

apps/lol_analytics_web/lib/lol_analytics_web/live/role_live/show.html.heex

@@ -0,0 +1,5 @@
+<.header>
+  Role <%= @role.id %>
+  <:subtitle>This is a role record from your database.</:subtitle>
+  <:actions></:actions>
+</.header>

apps/lol_analytics_web/lib/lol_analytics_web/router.ex

@@ -18,6 +18,12 @@ defmodule LoLAnalyticsWeb.Router do
     pipe_through :browser
 
     get "/", PageController, :home
+    live "/champions", ChampionLive.Index, :index
+    live "/champions/new", ChampionLive.Index, :new
+    live "/champions/:id/edit", ChampionLive.Index, :edit
+
+    live "/champions/:id", ChampionLive.Show, :show
+    live "/champions/:id/show/edit", ChampionLive.Show, :edit
   end
 
   # Other scopes may use custom stacks.

apps/lol_analytics_web/priv/static/robots-9e2c81b0855bbff2baa8371bc4a78186.txt

@@ -0,0 +1,5 @@
+# See https://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-agent: *
+# Disallow: /

apps/lol_analytics_web/test/lol_analytics_web/live/champion_live_test.exs

@@ -0,0 +1,108 @@
+defmodule LoLAnalyticsWeb.ChampionLiveTest do
+  use LoLAnalyticsWeb.ConnCase
+
+  import Phoenix.LiveViewTest
+  import LoLAnalytics.AccountsFixtures
+
+  @create_attrs %{}
+  @update_attrs %{}
+  @invalid_attrs %{}
+
+  defp create_champion(_) do
+    champion = champion_fixture()
+    %{champion: champion}
+  end
+
+  describe "Index" do
+    setup [:create_champion]
+
+    test "lists all champions", %{conn: conn} do
+      {:ok, _index_live, html} = live(conn, ~p"/champions")
+
+      assert html =~ "Listing Champions"
+    end
+
+    test "saves new champion", %{conn: conn} do
+      {:ok, index_live, _html} = live(conn, ~p"/champions")
+
+      assert index_live |> element("a", "New Champion") |> render_click() =~
+               "New Champion"
+
+      assert_patch(index_live, ~p"/champions/new")
+
+      assert index_live
+             |> form("#champion-form", champion: @invalid_attrs)
+             |> render_change() =~ "can't be blank"
+
+      assert index_live
+             |> form("#champion-form", champion: @create_attrs)
+             |> render_submit()
+
+      assert_patch(index_live, ~p"/champions")
+
+      html = render(index_live)
+      assert html =~ "Champion created successfully"
+    end
+
+    test "updates champion in listing", %{conn: conn, champion: champion} do
+      {:ok, index_live, _html} = live(conn, ~p"/champions")
+
+      assert index_live |> element("#champions-#{champion.id} a", "Edit") |> render_click() =~
+               "Edit Champion"
+
+      assert_patch(index_live, ~p"/champions/#{champion}/edit")
+
+      assert index_live
+             |> form("#champion-form", champion: @invalid_attrs)
+             |> render_change() =~ "can't be blank"
+
+      assert index_live
+             |> form("#champion-form", champion: @update_attrs)
+             |> render_submit()
+
+      assert_patch(index_live, ~p"/champions")
+
+      html = render(index_live)
+      assert html =~ "Champion updated successfully"
+    end
+
+    test "deletes champion in listing", %{conn: conn, champion: champion} do
+      {:ok, index_live, _html} = live(conn, ~p"/champions")
+
+      assert index_live |> element("#champions-#{champion.id} a", "Delete") |> render_click()
+      refute has_element?(index_live, "#champions-#{champion.id}")
+    end
+  end
+
+  describe "Show" do
+    setup [:create_champion]
+
+    test "displays champion", %{conn: conn, champion: champion} do
+      {:ok, _show_live, html} = live(conn, ~p"/champions/#{champion}")
+
+      assert html =~ "Show Champion"
+    end
+
+    test "updates champion within modal", %{conn: conn, champion: champion} do
+      {:ok, show_live, _html} = live(conn, ~p"/champions/#{champion}")
+
+      assert show_live |> element("a", "Edit") |> render_click() =~
+               "Edit Champion"
+
+      assert_patch(show_live, ~p"/champions/#{champion}/show/edit")
+
+      assert show_live
+             |> form("#champion-form", champion: @invalid_attrs)
+             |> render_change() =~ "can't be blank"
+
+      assert show_live
+             |> form("#champion-form", champion: @update_attrs)
+             |> render_submit()
+
+      assert_patch(show_live, ~p"/champions/#{champion}")
+
+      html = render(show_live)
+      assert html =~ "Champion updated successfully"
+    end
+  end
+end

apps/lol_analytics_web/test/lol_analytics_web/live/role_live_test.exs

@@ -0,0 +1,108 @@
+defmodule LoLAnalyticsWeb.RoleLiveTest do
+  use LoLAnalyticsWeb.ConnCase
+
+  import Phoenix.LiveViewTest
+  import LoLAnalytics.AccountsFixtures
+
+  @create_attrs %{}
+  @update_attrs %{}
+  @invalid_attrs %{}
+
+  defp create_role(_) do
+    role = role_fixture()
+    %{role: role}
+  end
+
+  describe "Index" do
+    setup [:create_role]
+
+    test "lists all roles", %{conn: conn} do
+      {:ok, _index_live, html} = live(conn, ~p"/roles")
+
+      assert html =~ "Listing Roles"
+    end
+
+    test "saves new role", %{conn: conn} do
+      {:ok, index_live, _html} = live(conn, ~p"/roles")
+
+      assert index_live |> element("a", "New Role") |> render_click() =~
+               "New Role"
+
+      assert_patch(index_live, ~p"/roles/new")
+
+      assert index_live
+             |> form("#role-form", role: @invalid_attrs)
+             |> render_change() =~ "can't be blank"
+
+      assert index_live
+             |> form("#role-form", role: @create_attrs)
+             |> render_submit()
+
+      assert_patch(index_live, ~p"/roles")
+
+      html = render(index_live)
+      assert html =~ "Role created successfully"
+    end
+
+    test "updates role in listing", %{conn: conn, role: role} do
+      {:ok, index_live, _html} = live(conn, ~p"/roles")
+
+      assert index_live |> element("#roles-#{role.id} a", "Edit") |> render_click() =~
+               "Edit Role"
+
+      assert_patch(index_live, ~p"/roles/#{role}/edit")
+
+      assert index_live
+             |> form("#role-form", role: @invalid_attrs)
+             |> render_change() =~ "can't be blank"
+
+      assert index_live
+             |> form("#role-form", role: @update_attrs)
+             |> render_submit()
+
+      assert_patch(index_live, ~p"/roles")
+
+      html = render(index_live)
+      assert html =~ "Role updated successfully"
+    end
+
+    test "deletes role in listing", %{conn: conn, role: role} do
+      {:ok, index_live, _html} = live(conn, ~p"/roles")
+
+      assert index_live |> element("#roles-#{role.id} a", "Delete") |> render_click()
+      refute has_element?(index_live, "#roles-#{role.id}")
+    end
+  end
+
+  describe "Show" do
+    setup [:create_role]
+
+    test "displays role", %{conn: conn, role: role} do
+      {:ok, _show_live, html} = live(conn, ~p"/roles/#{role}")
+
+      assert html =~ "Show Role"
+    end
+
+    test "updates role within modal", %{conn: conn, role: role} do
+      {:ok, show_live, _html} = live(conn, ~p"/roles/#{role}")
+
+      assert show_live |> element("a", "Edit") |> render_click() =~
+               "Edit Role"
+
+      assert_patch(show_live, ~p"/roles/#{role}/show/edit")
+
+      assert show_live
+             |> form("#role-form", role: @invalid_attrs)
+             |> render_change() =~ "can't be blank"
+
+      assert show_live
+             |> form("#role-form", role: @update_attrs)
+             |> render_submit()
+
+      assert_patch(show_live, ~p"/roles/#{role}")
+
+      html = render(show_live)
+      assert html =~ "Role updated successfully"
+    end
+  end
+end

apps/lol_api/lib/api/account_api.ex

@@ -18,7 +18,7 @@ defmodule LoLAPI.AccountApi do
       200 ->
         {:ok, Poison.decode(response.body)}
 
-      code ->
+      _code ->
         Logger.error("Error getting puuid from player #{name} \##{tag}")
         {:err, response.status_code}
     end

apps/scrapper/lib/scrapper/match_classifier.ex

@@ -1,19 +1,9 @@
 defmodule Scrapper.MatchClassifier do
   require Logger
 
-  @spec classify_match(%LoLAPI.Model.MatchResponse{}) :: nil
-  def classify_match(match = %LoLAPI.Model.MatchResponse{}) do
-    classify_match_by_queue(match.info.queueId)
-  end
-
-  @spec classify_match_by_queue(String.t()) :: nil
-  def classify_match_by_queue("420") do
-    matches = Storage.MatchStorage.S3MatchStorage.list_files("matches")
-    total_matches = Enum.count(matches)
-
-    matches
-    |> Enum.with_index(fn match, index -> {match, index} end)
-    |> Scrapper.Parallel.peach(fn {match, index} ->
+  def stream_classify_matches_by_queue(queue \\ 420, bucket \\ "ranked") do
+    Storage.MatchStorage.S3MatchStorage.stream_files("matches")
+    |> Stream.each(fn match ->
       %{key: json_file} = match
       [key | _] = String.split(json_file, ".")
 
@@ -25,15 +15,12 @@ defmodule Scrapper.MatchClassifier do
       %{"info" => %{"gameVersion" => gameVersion, "queueId" => queueId}} =
         Poison.decode!(response.body)
 
-      if queueId == 420 do
-        Storage.MatchStorage.S3MatchStorage.store_match(key, response.body, "ranked", gameVersion)
-        Logger.info("Match at #{index} of #{total_matches} is classified")
+      if queueId == queue do
+        Storage.MatchStorage.S3MatchStorage.store_match(key, response.body, bucket, gameVersion)
+        Logger.info("Match #{key} processed")
       end
 
       match
     end)
   end
-
-  def classify_match_by_queue(_) do
-  end
 end

apps/scrapper/lib/scrapper/processor/match_processor.ex

@@ -66,6 +66,6 @@ defmodule Scrapper.Processor.MatchProcessor do
     end)
   end
 
-  def process_resp({:err, code}, match_id) do
+  def process_resp({:err, _code}, _match_id) do
   end
 end

apps/scrapper/lib/scrapper/processor/player_processor.ex

@@ -1,5 +1,4 @@
 defmodule Scrapper.Processor.PlayerProcessor do
-  alias Calendar.ISO
   use Broadway
 
   def start_link(_opts) do

apps/scrapper/lib/scrapper/queue/match_queue.ex

@@ -19,7 +19,7 @@ defmodule Scrapper.Queue.MatchQueue do
     LolAnalytics.Match.MatchRepo.get_match(match_id)
     |> case do
       nil -> GenServer.call(__MODULE__, {:queue_match, match_id})
-      match -> :already_processed
+      _match -> :already_processed
     end
   end
 

apps/storage/lib/match_storage/match_storage.ex

@@ -1,6 +1,13 @@
 defmodule Storage.MatchStorage do
+  @callback stream_files(String.t()) :: Enumerable.t()
   @callback get_match(String.t()) :: {:ok, Scrapper.Data.Match.t()} | {:error, :not_found}
-  @callback save_match(String.t(), Scrapper.Data.Match.t()) :: :ok
-  @callback list_matches() :: [map()]
-  @callback store_match(match_id :: String.t(), match :: map(), path :: String.t()) :: String.t()
+  @callback store_match(match_id :: String.t(), match_data :: String.t(), path :: String.t()) ::
+              String.t()
+  @callback store_match(
+              match_id :: String.t(),
+              match_data :: String.t(),
+              bucket :: String.t(),
+              path :: String.t()
+            ) ::
+              String.t()
 end

apps/storage/lib/match_storage/s3_match_storage.ex

@@ -2,43 +2,14 @@ defmodule Storage.MatchStorage.S3MatchStorage do
   require Logger
   @behaviour Storage.MatchStorage
 
-  def get_match(match_id) do
-    ""
-  end
-
-  @doc """
-  Lists all files at the given path.
-
-  iex > Storage.MatchStorage.S3MatchStorage.list_files("matches")
-  """
   @impl true
-  def list_files(path) do
-    {:ok, %{:body => %{:contents => contents, next_continuation_token: next_continuation_token}}} =
-      ExAws.S3.list_objects_v2(path)
-      |> ExAws.request()
-
-    if next_continuation_token do
-      list_files(path, contents, next_continuation_token)
-      # |> Enum.map(fn %{key: key} -> key end)
-    else
-      contents
-      # |> Enum.map(fn %{key: key} -> key end)
-    end
+  def get_match(_match_id) do
   end
 
-  @spec list_files(String.t(), list(String.t()), String.t()) :: list(String.t())
-  defp list_files(path, acc, continuation_token) do
-    resp =
-      {:ok,
-       %{:body => %{:contents => contents, next_continuation_token: next_continuation_token}}} =
-      ExAws.S3.list_objects_v2(path, continuation_token: continuation_token)
-      |> ExAws.request()
-
-    if next_continuation_token == "" do
-      acc ++ contents
-    else
-      list_files(path, acc ++ contents, next_continuation_token)
-    end
+  @impl true
+  def stream_files(path) do
+    ExAws.S3.list_objects_v2(path)
+    |> ExAws.stream!()
   end
 
   @doc """

config/prod.exs

@@ -8,7 +8,7 @@ import Config
 config :lol_analytics_web, LoLAnalyticsWeb.Endpoint,
   server: true,
   http: [ip: {0, 0, 0, 0}, port: 4000],
-  url: [host: "lol-analytics.kaizer.cloud", port: 80],
+  url: [host: "localhost", port: 80],
   cache_static_manifest: "priv/static/cache_manifest.json"
 
 # Do not print debug messages in production

config/runtime.exs

@@ -6,7 +6,7 @@ import Config
 # and secrets from environment variables or elsewhere. Do not define
 # any compile-time configuration in here, as it won't be applied.
 # The block below contains prod specific runtime configuration.
-if config_env() == :prod do
+if config_env() == :prod || true do
   database_url =
     System.get_env("DATABASE_URL") ||
       raise """

docker-compose.yml

@@ -0,0 +1,36 @@
+version: '3.8'
+services:
+  db:
+    image: postgres:latest
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    environment:
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_USER: postgres
+      POSTGRES_DB: postgres
+    ports:
+      - "5432:5432"
+  rabbitmq:
+    image: rabbitmq:3-management-alpine
+    container_name: 'rabbitmq'
+    ports:
+      - "15671:15671"
+      - "15672:15672"
+      - "15691:15691"
+      - "15692:15692"
+      - "25672:25672"
+      - "4639:4639"
+      - "5671:5671"
+      - "5672:5672"
+    volumes:
+      - ~/.docker-conf/rabbitmq/data/:/var/lib/rabbitmq/
+      - ~/.docker-conf/rabbitmq/log/:/var/log/rabbitmq
+    networks:
+      - rabbitmq_go_net
+volumes:
+  postgres-data:
+
+
+networks:
+  rabbitmq_go_net:
+    driver: bridge

queries.md

@@ -0,0 +1,22 @@
+```
+SELECT 
+	(cast(count(CASE WHEN is_win THEN 1 END) as float) / cast(count(*) as float)) * 100.0 as win_rate, 
+	count(CASE WHEN is_win THEN 1 END) as games_won, 
+	count(*) as total_games, 
+	champion_id
+	FROM fact_champion_played_game 
+	GROUP BY champion_id
+	ORDER BY win_rate desc;
+```
+
+```
+SELECT 
+	(cast(count(CASE WHEN is_win THEN 1 END) as float) / cast(count(*) as float)) * 100.0 as win_rate, 
+	count(CASE WHEN is_win THEN 1 END) as games_won, 
+	count(*) as total_games, 
+	champion_id,
+    team_position
+	FROM fact_champion_played_game 
+	GROUP BY champion_id, team_position
+	ORDER BY win_rate desc;
+```