feat: implement datadragon and player sync (#9)

* feat: implement datadragon and player sync

  1. Data Dragon Service - Busca dados estáticos da Riot
  2. Região Configurável - Não mais hardcoded, usa player.region
  3. Champion Mapping - Funcionando corretamente agora
  4. 8 Novos API Endpoints - Para dados da Riot
  5. 5 Rake Tasks - Gerenciamento de cache e sync
  6. Suite de Testes - Criada para SyncPlayerFromRiotJob

* chore: add admin bypass ruleset

Author: Bulletdev

.github/branch-protection-ruleset.json

@@ -49,5 +49,11 @@
       "type": "creation"
     }
   ],
-  "bypass_actors": []
+  "bypass_actors": [
+    {
+      "actor_id": 1,
+      "actor_type": "RepositoryRole",
+      "bypass_mode": "always"
+    }
+  ]
 }

app/controllers/api/v1/riot_data_controller.rb

@@ -0,0 +1,144 @@
+module Api
+  module V1
+    class RiotDataController < BaseController
+      skip_before_action :authenticate_request!, only: [:champions, :champion_details, :items, :version]
+
+      # GET /api/v1/riot-data/champions
+      def champions
+        service = DataDragonService.new
+        champions = service.champion_id_map
+
+        render_success({
+          champions: champions,
+          count: champions.count
+        })
+      rescue DataDragonService::DataDragonError => e
+        render_error('Failed to fetch champion data', :service_unavailable, details: e.message)
+      end
+
+      # GET /api/v1/riot-data/champions/:champion_key
+      def champion_details
+        service = DataDragonService.new
+        champion = service.champion_by_key(params[:champion_key])
+
+        if champion.present?
+          render_success({
+            champion: champion
+          })
+        else
+          render_error('Champion not found', :not_found)
+        end
+      rescue DataDragonService::DataDragonError => e
+        render_error('Failed to fetch champion details', :service_unavailable, details: e.message)
+      end
+
+      # GET /api/v1/riot-data/all-champions
+      def all_champions
+        service = DataDragonService.new
+        champions = service.all_champions
+
+        render_success({
+          champions: champions,
+          count: champions.count
+        })
+      rescue DataDragonService::DataDragonError => e
+        render_error('Failed to fetch champions', :service_unavailable, details: e.message)
+      end
+
+      # GET /api/v1/riot-data/items
+      def items
+        service = DataDragonService.new
+        items = service.items
+
+        render_success({
+          items: items,
+          count: items.count
+        })
+      rescue DataDragonService::DataDragonError => e
+        render_error('Failed to fetch items', :service_unavailable, details: e.message)
+      end
+
+      # GET /api/v1/riot-data/summoner-spells
+      def summoner_spells
+        service = DataDragonService.new
+        spells = service.summoner_spells
+
+        render_success({
+          summoner_spells: spells,
+          count: spells.count
+        })
+      rescue DataDragonService::DataDragonError => e
+        render_error('Failed to fetch summoner spells', :service_unavailable, details: e.message)
+      end
+
+      # GET /api/v1/riot-data/version
+      def version
+        service = DataDragonService.new
+        version = service.latest_version
+
+        render_success({
+          version: version
+        })
+      rescue DataDragonService::DataDragonError => e
+        render_error('Failed to fetch version', :service_unavailable, details: e.message)
+      end
+
+      # POST /api/v1/riot-data/clear-cache
+      def clear_cache
+        authorize :riot_data, :manage?
+
+        service = DataDragonService.new
+        service.clear_cache!
+
+        log_user_action(
+          action: 'clear_cache',
+          entity_type: 'RiotData',
+          entity_id: nil,
+          details: { message: 'Data Dragon cache cleared' }
+        )
+
+        render_success({
+          message: 'Cache cleared successfully'
+        })
+      end
+
+      # POST /api/v1/riot-data/update-cache
+      def update_cache
+        authorize :riot_data, :manage?
+
+        service = DataDragonService.new
+        service.clear_cache!
+
+        # Preload all data
+        version = service.latest_version
+        champions = service.champion_id_map
+        items = service.items
+        spells = service.summoner_spells
+
+        log_user_action(
+          action: 'update_cache',
+          entity_type: 'RiotData',
+          entity_id: nil,
+          details: {
+            version: version,
+            champions_count: champions.count,
+            items_count: items.count,
+            spells_count: spells.count
+          }
+        )
+
+        render_success({
+          message: 'Cache updated successfully',
+          version: version,
+          data: {
+            champions: champions.count,
+            items: items.count,
+            summoner_spells: spells.count
+          }
+        })
+      rescue DataDragonService::DataDragonError => e
+        render_error('Failed to update cache', :service_unavailable, details: e.message)
+      end
+    end
+  end
+end

app/jobs/sync_player_from_riot_job.rb

@@ -20,7 +20,8 @@ def perform(player_id)
     end
 
     begin
-      region = 'br1' # TODO: Make this configurable per player
+      # Use player's region or default to BR1
+      region = player.region.presence&.downcase || 'br1'
 
       # Fetch summoner data
       if player.riot_puuid.present?

app/jobs/sync_player_job.rb

@@ -148,12 +148,6 @@ def current_season
   end
 
   def load_champion_id_map
-    # This is a simplified version. In production, you would load this from Data Dragon
-    # or cache it in Redis
-    Rails.cache.fetch('riot:champion_id_map', expires_in: 1.week) do
-      # Fetch from Data Dragon API or use a static file
-      # For now, return an empty hash
-      {}
-    end
+    DataDragonService.new.champion_id_map
   end
 end

app/jobs/sync_scouting_target_job.rb

@@ -108,8 +108,6 @@ def should_update_peak?(target, new_tier, new_rank)
   end
 
   def load_champion_id_map
-    Rails.cache.fetch('riot:champion_id_map', expires_in: 1.week) do
-      {}
-    end
+    DataDragonService.new.champion_id_map
   end
 end

app/policies/riot_data_policy.rb

@@ -0,0 +1,11 @@
+class RiotDataPolicy < ApplicationPolicy
+  def manage?
+    user.admin_or_owner?
+  end
+
+  class Scope < Scope
+    def resolve
+      scope.all
+    end
+  end
+end

app/services/data_dragon_service.rb

@@ -0,0 +1,186 @@
+class DataDragonService
+  BASE_URL = 'https://ddragon.leagueoflegends.com'.freeze
+
+  class DataDragonError < StandardError; end
+
+  def initialize
+    @latest_version = nil
+  end
+
+  # Get the latest game version
+  def latest_version
+    @latest_version ||= fetch_latest_version
+  end
+
+  # Get champion ID to name mapping
+  def champion_id_map
+    Rails.cache.fetch('riot:champion_id_map', expires_in: 1.week) do
+      fetch_champion_data
+    end
+  end
+
+  # Get champion name to ID mapping (reverse)
+  def champion_name_map
+    Rails.cache.fetch('riot:champion_name_map', expires_in: 1.week) do
+      champion_id_map.invert
+    end
+  end
+
+  # Get all champions data (full details)
+  def all_champions
+    Rails.cache.fetch('riot:all_champions', expires_in: 1.week) do
+      fetch_all_champions_data
+    end
+  end
+
+  # Get specific champion data by key
+  def champion_by_key(champion_key)
+    all_champions[champion_key]
+  end
+
+  # Get profile icons data
+  def profile_icons
+    Rails.cache.fetch('riot:profile_icons', expires_in: 1.week) do
+      fetch_profile_icons
+    end
+  end
+
+  # Get summoner spells data
+  def summoner_spells
+    Rails.cache.fetch('riot:summoner_spells', expires_in: 1.week) do
+      fetch_summoner_spells
+    end
+  end
+
+  # Get items data
+  def items
+    Rails.cache.fetch('riot:items', expires_in: 1.week) do
+      fetch_items
+    end
+  end
+
+  # Clear all cached data
+  def clear_cache!
+    Rails.cache.delete('riot:champion_id_map')
+    Rails.cache.delete('riot:champion_name_map')
+    Rails.cache.delete('riot:all_champions')
+    Rails.cache.delete('riot:profile_icons')
+    Rails.cache.delete('riot:summoner_spells')
+    Rails.cache.delete('riot:items')
+    Rails.cache.delete('riot:latest_version')
+    @latest_version = nil
+  end
+
+  private
+
+  def fetch_latest_version
+    cached_version = Rails.cache.read('riot:latest_version')
+    return cached_version if cached_version.present?
+
+    url = "#{BASE_URL}/api/versions.json"
+    response = make_request(url)
+    versions = JSON.parse(response.body)
+
+    latest = versions.first
+    Rails.cache.write('riot:latest_version', latest, expires_in: 1.day)
+    latest
+  rescue StandardError => e
+    Rails.logger.error("Failed to fetch latest version: #{e.message}")
+    # Fallback to a recent known version
+    '14.1.1'
+  end
+
+  def fetch_champion_data
+    version = latest_version
+    url = "#{BASE_URL}/cdn/#{version}/data/en_US/champion.json"
+
+    response = make_request(url)
+    data = JSON.parse(response.body)
+
+    # Create mapping: champion_id (integer) => champion_name (string)
+    champion_map = {}
+    data['data'].each do |_key, champion|
+      champion_id = champion['key'].to_i
+      champion_name = champion['id'] # This is the champion name like "Aatrox"
+      champion_map[champion_id] = champion_name
+    end
+
+    champion_map
+  rescue StandardError => e
+    Rails.logger.error("Failed to fetch champion data: #{e.message}")
+    {}
+  end
+
+  def fetch_all_champions_data
+    version = latest_version
+    url = "#{BASE_URL}/cdn/#{version}/data/en_US/champion.json"
+
+    response = make_request(url)
+    data = JSON.parse(response.body)
+
+    data['data']
+  rescue StandardError => e
+    Rails.logger.error("Failed to fetch all champions data: #{e.message}")
+    {}
+  end
+
+  def fetch_profile_icons
+    version = latest_version
+    url = "#{BASE_URL}/cdn/#{version}/data/en_US/profileicon.json"
+
+    response = make_request(url)
+    data = JSON.parse(response.body)
+
+    data['data']
+  rescue StandardError => e
+    Rails.logger.error("Failed to fetch profile icons: #{e.message}")
+    {}
+  end
+
+  def fetch_summoner_spells
+    version = latest_version
+    url = "#{BASE_URL}/cdn/#{version}/data/en_US/summoner.json"
+
+    response = make_request(url)
+    data = JSON.parse(response.body)
+
+    data['data']
+  rescue StandardError => e
+    Rails.logger.error("Failed to fetch summoner spells: #{e.message}")
+    {}
+  end
+
+  def fetch_items
+    version = latest_version
+    url = "#{BASE_URL}/cdn/#{version}/data/en_US/item.json"
+
+    response = make_request(url)
+    data = JSON.parse(response.body)
+
+    data['data']
+  rescue StandardError => e
+    Rails.logger.error("Failed to fetch items: #{e.message}")
+    {}
+  end
+
+  def make_request(url)
+    conn = Faraday.new do |f|
+      f.request :retry, max: 3, interval: 0.5, backoff_factor: 2
+      f.adapter Faraday.default_adapter
+    end
+
+    response = conn.get(url) do |req|
+      req.options.timeout = 10
+    end
+
+    unless response.success?
+      raise DataDragonError, "Request failed with status #{response.status}"
+    end
+
+    response
+  rescue Faraday::TimeoutError => e
+    raise DataDragonError, "Request timeout: #{e.message}"
+  rescue Faraday::Error => e
+    raise DataDragonError, "Network error: #{e.message}"
+  end
+end