purtea 0.0.1

data/google_credentials.example.json

@@ -0,0 +1,14 @@
+{
+  "installed": {
+    "client_id": "CLIENT_ID_HERE",
+    "project_id": "PROJECT_ID_HERE",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_secret": "CLIENT_SECRET_HERE",
+    "redirect_uris": [
+      "urn:ietf:wg:oauth:2.0:oob",
+      "http://localhost"
+    ]
+  }
+}

data/lib/purtea.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# A tool to handle importing of FF Logs TEA stats to a Google Sheet.
+module Purtea; end
+
+require 'purtea/version'
+require 'purtea/logging'
+require 'purtea/config'
+
+require 'purtea/fflogs'
+require 'purtea/sheet'
+
+require 'purtea/cli'

data/lib/purtea/cli.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'gli'
+
+TEA_ZONE_ID = 887
+
+def format_percentage(percentage)
+  if percentage.nil?
+    'N/A'
+  else
+    format('%.2f%%', percentage)
+  end
+end
+
+def float_comp(first, second)
+  (first - second).abs < Float::EPSILON
+end
+
+def calc_end_phase(fight) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+  return '???' unless fight.zone_id == TEA_ZONE_ID
+
+  return 'N/A' if fight.boss_percentage.nil? || fight.fight_percentage.nil?
+
+  if fight.boss_percentage.zero? && fight.fight_percentage >= 80.0
+    return 'Living Liquid (LL)'
+  end
+
+  if fight.boss_percentage.positive? && fight.fight_percentage > 75.0
+    return 'Living Liquid (LL)'
+  end
+
+  if fight.boss_percentage.zero? && float_comp(fight.fight_percentage, 75.0)
+    return 'Limit Cut (LC)'
+  end
+
+  if fight.fight_percentage >= 50.0 && fight.fight_percentage <= 75.0 &&
+     fight.boss_percentage >= 0.0
+    return 'Brute Justice / Cruise Chaser (BJ/CC)'
+  end
+
+  if fight.fight_percentage <= 50.0 && fight.fight_percentage >= 30.0
+    return 'Alexander Prime (AP)'
+  end
+
+  'Perfect Alexander (PA)'
+end
+
+def parse_fight(fight) # rubocop:disable Metrics/AbcSize
+  [
+    fight.id,
+    fight.encounter_id,
+    fight.zone_id,
+    fight.zone_name,
+    fight.name,
+    fight.difficulty,
+    format_percentage(fight.boss_percentage),
+    format_percentage(fight.fight_percentage),
+    fight.start_at.strftime(Purtea::FFLogs::Fight::ISO_FORMAT),
+    fight.end_at.strftime(Purtea::FFLogs::Fight::ISO_FORMAT),
+    fight.duration.strftime('%H:%M:%S'),
+    calc_end_phase(fight),
+    fight.kill? ? 'Y' : 'N'
+  ]
+end
+
+module Purtea
+  # Defines the CLI interface for Purtea.
+  class CLI
+    extend GLI::App
+
+    program_desc 'FF Logs TEA stats import tool'
+    program_long_desc <<~LONGDESC
+      This tool helps you import TEA stats from FF Logs and writing it to a
+      Google Sheet.
+    LONGDESC
+    version Purtea::VERSION
+
+    subcommand_option_handling :normal
+    arguments :strict
+
+    desc 'Be verbose'
+    switch %i[v verbose]
+
+    pre do |global_options, _options, _args|
+      if global_options[:verbose]
+        Purtea.logger.debug!
+      else
+        Purtea.logger.info!
+      end
+    end
+
+    desc 'Import FF Logs report to Google Sheet'
+    long_desc <<~LONGDESC
+      report_code should be the code for a report containing TEA fights on
+      FF Logs.
+
+      The tool will read the fight stats and import it as a table into the
+      configured Google Sheet (at the configured range).
+    LONGDESC
+    arg :report_code
+    command :import do |c|
+      c.action do |_, _, args|
+        code = args.shift
+        config = Purtea::Config.load
+        fflogs_api = Purtea::FFLogs::API.new(
+          config['fflogs']['client_id'],
+          config['fflogs']['client_secret']
+        )
+        fights = fflogs_api.fights(code).select { |f| f.zone_id == TEA_ZONE_ID }
+
+        spreadsheet_data = fights.map { |f| parse_fight(f) }
+
+        sheet = Purtea::SheetApi.new(config['sheet']['id'])
+        sheet.append(config['sheet']['range'], spreadsheet_data)
+      end
+    end
+
+    desc 'Tests the logging system'
+    command :testlog do |c|
+      c.action do
+        l = Purtea.logger
+        l.debug('This is a debug log')
+        l.info('This is an info log')
+        l.warn('This is a warn log')
+        l.error('This is an error log')
+        l.fatal('This is a fatal log')
+        l.unknown('This is an unknown log')
+      end
+    end
+  end
+end

data/lib/purtea/config.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'dotenv/load'
+require 'fileutils'
+require 'tomlrb'
+
+module Purtea
+  # Contains methods to load the Purtea config.
+  module Config
+    DEFAULT_CONFIG_PATH = 'config.toml'
+    DEFAULT_ENV_PREFIX = 'PURTEA_'
+    ENV_NESTED_SEPARATOR = '__'
+
+    class << self
+      def load(path = DEFAULT_CONFIG_PATH, env_prefix: DEFAULT_ENV_PREFIX)
+        path = resolve_file path, create_dir: true
+        config = if File.exist? path
+                   Tomlrb.load_file path
+                 else
+                   {}
+                 end
+
+        ENV.select { |k, _| k.start_with? env_prefix }.each do |key, value|
+          key_path = key
+                     .delete_prefix(env_prefix)
+                     .split(ENV_NESTED_SEPARATOR)
+                     .map(&:downcase)
+          set_hash_by_path config, key_path, value unless key_path.empty?
+        end
+
+        config
+      end
+
+      def resolve_directory(create: false)
+        base = ENV['XDG_CONFIG_HOME'] || File.join(Dir.home, '.config')
+        File.join(base, 'purtea').tap do |path|
+          if create && !Dir.exist?(path)
+            Purtea.logger.debug(
+              "Config directory doesn't exist, creating #{path}"
+            )
+            FileUtils.mkpath(path)
+          end
+        end
+      end
+
+      def resolve_file(file, create_dir: false)
+        directory = resolve_directory create: create_dir
+        File.join directory, file
+      end
+
+      private
+
+      def set_hash_by_path(hash, key_path, value)
+        if key_path.size == 1
+          hash[key_path[0]] = value
+          return
+        end
+
+        key = key_path.shift
+
+        if hash[key].nil?
+          hash[key] = {}
+        elsif !hash[key].is_a? Hash
+          raise ArgumentError, 'Specified key path contains a value'
+        end
+
+        set_hash_by_path hash[key], key_path, value
+      end
+    end
+  end
+end

data/lib/purtea/fflogs.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'graphql/client'
+require 'graphql/client/http'
+
+require 'purtea/fflogs/fight'
+require 'purtea/fflogs/api'
+
+module Purtea
+  module FFLogs
+    BASE_URL = 'https://www.fflogs.com'
+    API_URL = "#{BASE_URL}/api/v2/client"
+    SCHEMA_FILE = File.expand_path('../../fflogs_schema.json', __dir__)
+
+    HTTP = GraphQL::Client::HTTP.new(API_URL) do
+      def headers(context)
+        unless (token = context[:access_token])
+          raise 'Missing FF Logs access token'
+        end
+
+        {
+          'Authorization' => "Bearer #{token}"
+        }
+      end
+    end
+
+    CLIENT = GraphQL::Client.new(
+      schema: SCHEMA_FILE,
+      execute: HTTP
+    )
+
+    GET_FIGHTS_QUERY = CLIENT.parse <<-GRAPHQL
+      query($code: String) {
+        reportData {
+          report(code: $code) {
+            startTime
+            endTime
+            fights {
+              id
+              encounterID
+              gameZone {
+                id
+                name
+              }
+              name
+              difficulty
+              bossPercentage
+              fightPercentage
+              startTime
+              endTime
+              kill
+            }
+          }
+        }
+        rateLimitData {
+          limitPerHour
+          pointsResetIn
+          pointsSpentThisHour
+        }
+      }
+    GRAPHQL
+  end
+end

data/lib/purtea/fflogs/api.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'oauth2'
+require 'time'
+
+module Purtea
+  module FFLogs
+    TOKEN_FILE = Purtea::Config.resolve_file(
+      'fflogs_token.json',
+      create_dir: true
+    )
+    EXPIRATION_THRESHOLD = 30
+
+    # Contains methods to interact with the FF Logs API.
+    class API
+      def initialize(client_id, client_secret)
+        @client_id = client_id
+        @client_secret = client_secret
+        @oa_client = OAuth2::Client.new(
+          @client_id, @client_secret, site: BASE_URL
+        )
+        authorize!
+      end
+
+      def dump_schema(is_retry: false)
+        result = GraphQL::Client.dump_schema(
+          Purtea::FFLogs::HTTP,
+          SCHEMA_FILE,
+          context: { access_token: @token.token }
+        )
+
+        err_code = result&.dig('errors', 0, 'message')&.[](0..2)
+        if err_code && err_code == '401'
+          return result if is_retry
+
+          Purtea.logger.info 'FF Logs API token expired or revoked, getting new'
+
+          authorize! true
+          return dump_schema true
+        end
+
+        result
+      end
+
+      def fights(code)
+        result = CLIENT.query(
+          GET_FIGHTS_QUERY,
+          variables: { code: code },
+          context: { access_token: @token.token }
+        )
+
+        report = result.data.report_data.report
+        report.fights.map { |d| Fight.new d, report.start_time }
+      end
+
+      def authorize!(force_refresh: false)
+        Purtea.logger.debug 'Authorize FF Logs API'
+
+        unless force_refresh
+          load_token!
+          return unless token_expired?
+        end
+
+        refresh_token!
+        save_token
+      end
+
+      def save_token
+        return if @token.nil?
+
+        Purtea.logger.debug 'Saving FF Logs API token to file'
+        token_hash = @token.to_hash
+        token_json = token_hash.to_json
+        File.open(TOKEN_FILE, 'w') { |f| f.write token_json }
+      end
+
+      def load_token!
+        return unless File.exist? TOKEN_FILE
+
+        Purtea.logger.debug 'Loading FF Logs API token from file'
+        token_hash = JSON.load_file TOKEN_FILE
+        @token = OAuth2::AccessToken.from_hash(@oa_client, token_hash)
+      end
+
+      def refresh_token!
+        # FF Logs does not issue refresh tokens
+        Purtea.logger.debug 'Refreshing FF Logs API token'
+        @token = @oa_client.client_credentials.get_token
+      end
+
+      def token_expired?
+        return true if @token.nil?
+
+        expires_at = Time.at(@token.expires_at)
+        time_until_expire = expires_at - Time.now
+        time_until_expire < EXPIRATION_THRESHOLD
+      end
+    end
+  end
+end

data/lib/purtea/fflogs/fight.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Purtea
+  module FFLogs
+    # Describes a fight entry in FF Logs.
+    class Fight
+      ISO_FORMAT = '%Y-%m-%dT%H:%M:%S%:z'
+
+      attr_reader :id, :encounter_id, :zone_id, :name, :zone_name, :difficulty,
+                  :boss_percentage, :fight_percentage, :start_at, :end_at,
+                  :duration
+
+      # rubocop:disable Metrics/AbcSize
+      def initialize(data, report_start_ms)
+        @id = data.id
+        @encounter_id = data.encounter_id
+        @zone_id = data.game_zone.id
+        @name = data.name
+        @zone_name = data.game_zone.name
+        @difficulty = data.difficulty
+        @boss_percentage = data.boss_percentage
+        @fight_percentage = data.fight_percentage
+        @start_at = parse_fight_timestamp report_start_ms, data.start_time
+        @end_at = parse_fight_timestamp report_start_ms, data.end_time
+        @kill = data.kill
+        @duration = parse_duration @start_at, @end_at
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def kill?
+        @kill
+      end
+
+      def to_s
+        start_f = start_at.strftime(ISO_FORMAT)
+        end_f = end_at.strftime(ISO_FORMAT)
+        duration = Time.at(end_at - start_at).utc.strftime('%H:%M:%S')
+        kw = kill? ? 'CLEAR' : 'WIPE'
+        "[#{@id}] #{start_f} -> #{end_f} [#{duration}] " \
+          "#{boss_percentage}% (#{fight_percentage}%) - #{kw}"
+      end
+
+      private
+
+      def parse_fight_timestamp(report_start_ms, time)
+        Time.at(0, report_start_ms + time, :millisecond)
+      end
+
+      def parse_duration(start_at, end_at)
+        Time.at(end_at - start_at).utc
+      end
+    end
+  end
+end