.",
+ color: 15_158_332,
+ footer: { text: "TornManager Status Monitor" },
+ timestamp: Time.current.iso8601
+ }
+ )
+
+ TornApiHealthCheckJob.perform_later(path)
+ rescue => e
+ Rails.logger.error("[Discord Torn Degraded Notify] Failed: #{e.message}")
+ end
+
+ def invalidate_api_key!
+ return if api_key == AdminCredentials.api_key
+
+ record = ::ApiKey.find_by(key: api_key)
+ return unless record
+
+ if record.faction_id?
+ record.faction.handle_invalid_api_key!
+ else
+ record.destroy!
+ end
+ rescue => e
+ Rails.logger.error("[TornAPI] Failed to invalidate API key: #{e.message}")
+ end
+
+ def resolve_api_key_owner
+ @resolved_user ||= begin
+ found = ::User.find_by_api_key(api_key)
+ return found if found
+
+ ::User.find_by(torn_id: ::User::ADMIN_TORN_ID) if api_key == AdminCredentials.api_key
end
end
end
diff --git a/app/models/torn_api/faction/armory.rb b/app/models/torn_api/faction/armory.rb
new file mode 100644
index 0000000..2e652f5
--- /dev/null
+++ b/app/models/torn_api/faction/armory.rb
@@ -0,0 +1,88 @@
+module TornApi
+ module Faction
+ class Armory < Base
+ SELECTIONS = "weapons,armor"
+
+ ARMOR_SLOT_MAP = {
+ "Helmet" => :head,
+ "Body" => :chest,
+ "Vest" => :chest,
+ "Armor" => :chest,
+ "Gloves" => :chest, # fallback, overridden below
+ "Pants" => :pants,
+ "Boots" => :boots
+ }.freeze
+
+ def initialize(api_key, faction_torn_id = nil)
+ super(api_key)
+ @faction_torn_id = faction_torn_id
+ end
+
+ def endpoint
+ base = "v2/faction"
+ base = "#{base}/#{@faction_torn_id}" if @faction_torn_id
+ base
+ end
+
+ def fetch
+ get(endpoint, { selections: SELECTIONS, striptags: false })
+ end
+
+ def fetch_by_member
+ response = fetch
+ members = Hash.new { |h, k| h[k] = empty_slots }
+
+ parse_items(response["armor"] || [], members, :armor)
+ parse_items(response["weapons"] || [], members, :weapon)
+
+ members
+ end
+
+ private
+
+ def empty_slots
+ { head: [], chest: [], gloves: [], pants: [], boots: [], primary: [], secondary: [], melee: [] }
+ end
+
+ def parse_items(items, members, category)
+ items.each do |item|
+ next unless (item["loaned"] || 0) > 0
+
+ loaned_to = parse_loaned_to(item["loaned_to"])
+ name = item["name"]
+ slot = category == :armor ? armor_slot(name) : weapon_slot(item["type"])
+
+ loaned_to.each do |member_id|
+ members[member_id][slot] << name
+ end
+ end
+ end
+
+ def parse_loaned_to(value)
+ case value
+ when Integer then [ value ]
+ when String then value.split(",").map { |id| id.strip.to_i }
+ when Array then value.map(&:to_i)
+ else []
+ end
+ end
+
+ def armor_slot(name)
+ return :head if name.match?(/helmet|gas mask/i)
+ return :gloves if name.match?(/gloves/i)
+ return :boots if name.match?(/boots/i)
+ return :pants if name.match?(/pants/i)
+ :chest
+ end
+
+ def weapon_slot(type)
+ case type
+ when "Primary" then :primary
+ when "Secondary" then :secondary
+ when "Melee" then :melee
+ else :primary
+ end
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/faction/armory_news.rb b/app/models/torn_api/faction/armory_news.rb
new file mode 100644
index 0000000..de9cb19
--- /dev/null
+++ b/app/models/torn_api/faction/armory_news.rb
@@ -0,0 +1,103 @@
+module TornApi
+ module Faction
+ class ArmoryNews < Base
+ V1_ENDPOINT = "faction"
+
+ def fetch(from: nil, to: nil, limit: 100, sort: nil)
+ params = { selections: "armorynews", limit: [ limit, 100 ].min }
+ params[:from] = from.to_i if from
+ params[:to] = to.to_i if to
+ params[:sort] = sort if sort
+ response = get(V1_ENDPOINT, params)
+ parse(response["armorynews"])
+ end
+
+ def fetch_all(since: 1.year.ago, max_entries: 2000)
+ all_entries = []
+ cursor_to = nil
+ floor = since.to_i
+
+ loop do
+ params = { selections: "armorynews", limit: 100, sort: "DESC" }
+ params[:to] = cursor_to if cursor_to
+ params[:from] = floor
+
+ response = get(V1_ENDPOINT, params)
+ batch = parse(response["armorynews"])
+ break if batch.empty?
+
+ all_entries.concat(batch)
+ break if all_entries.size >= max_entries
+ break if batch.size < 100
+
+ cursor_to = batch.map { |e| e[:timestamp] }.min - 1
+ break if cursor_to < floor
+ end
+
+ all_entries.first(max_entries)
+ end
+
+ private
+
+ def parse(entries)
+ return [] unless entries
+
+ list = if entries.is_a?(Hash)
+ entries.map { |id, entry| build_entry(id, entry) }
+ elsif entries.is_a?(Array)
+ entries.map { |entry| build_entry(entry["id"], entry) }
+ else
+ []
+ end
+
+ list.compact
+ end
+
+ def build_entry(id, entry)
+ return nil unless entry && entry["news"] && entry["timestamp"]
+
+ text = entry["news"]
+ player_name = text[/>([^<]+)<\/a>/, 1]
+ player_id = text[/XID=(\d+)/, 1]&.to_i
+
+ plain = text.gsub(/<[^>]+>/, "").strip
+ action, item = parse_action(plain, player_name)
+
+ {
+ id: id,
+ text: ActionController::Base.helpers.sanitize(text, tags: %w[a], attributes: %w[href]),
+ timestamp: entry["timestamp"],
+ player_name: player_name,
+ player_id: player_id,
+ action: action,
+ item: item
+ }
+ end
+
+ def parse_action(plain, player_name)
+ after_name = plain.sub(/\A#{Regexp.escape(player_name.to_s)}\s*/, "")
+
+ case after_name
+ when /\Aloaned (\d+)x (.+?) to/
+ [ :loaned, $2 ]
+ when /\Agave (\d+)x (.+?) to/
+ [ :loaned, $2 ]
+ when /\Areturned (\d+)x (.+)/
+ [ :returned, $2 ]
+ when /\Aretrieved (\d+)x (.+?) from/
+ [ :returned, $2 ]
+ when /\Adeposited (\d+)\s*x (.+)/
+ [ :deposited, $2 ]
+ when /\Aused one of the faction's (.+?) items/
+ [ :used, $1 ]
+ when /\Afilled .+ to create a (.+)/
+ [ :filled, $1 ]
+ when /\Afilled one of the faction's (.+?) items/
+ [ :filled, $1 ]
+ else
+ [ :unknown, after_name ]
+ end
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/faction/attacks.rb b/app/models/torn_api/faction/attacks.rb
new file mode 100644
index 0000000..10a9a7a
--- /dev/null
+++ b/app/models/torn_api/faction/attacks.rb
@@ -0,0 +1,115 @@
+module TornApi
+ module Faction
+ class Attacks < Base
+ Attack = Data.define(
+ :id, :code, :started, :ended,
+ :attacker_id, :attacker_name, :attacker_level, :attacker_faction_id, :attacker_faction_name,
+ :defender_id, :defender_name, :defender_level, :defender_faction_id, :defender_faction_name,
+ :result, :respect_gain, :respect_loss, :chain,
+ :is_ranked_war, :is_stealthed, :is_interrupted, :is_raid,
+ :fair_fight, :war, :retaliation, :group, :overseas, :chain_modifier, :warlord,
+ :finishing_hit_effects
+ )
+
+ Result = Data.define(:attacks, :prev_url)
+
+ def initialize(api_key, from: nil, to: nil, filters: nil, limit: 100)
+ super(api_key)
+ @from = from
+ @to = to
+ @filters = filters
+ @limit = limit
+ end
+
+ MAX_PAGES = 50
+
+ def fetch
+ response = get("v2/faction/attacks", build_params)
+
+ attacks = (response["attacks"] || []).map { |a| parse_attack(a) }
+ prev_url = response.dig("_metadata", "links", "prev")
+
+ Result.new(attacks: attacks, prev_url: prev_url)
+ end
+
+ def fetch_all(max_pages: MAX_PAGES)
+ all_attacks = []
+ current_to = @to
+ pages = 0
+
+ loop do
+ break if pages >= max_pages
+
+ params = build_params(to_override: current_to)
+ response = get("v2/faction/attacks", params)
+
+ attacks = (response["attacks"] || []).map { |a| parse_attack(a) }
+ all_attacks.concat(attacks)
+ pages += 1
+
+ prev_url = response.dig("_metadata", "links", "prev")
+ break unless prev_url
+
+ current_to = extract_to_param(prev_url)
+ break unless current_to
+ end
+
+ all_attacks
+ end
+
+ private
+
+ def build_params(to_override: nil)
+ params = { limit: @limit, sort: "DESC" }
+ params[:from] = @from if @from
+ to_val = to_override || @to
+ params[:to] = to_val if to_val
+ params[:filters] = @filters if @filters
+ params
+ end
+
+ def extract_to_param(url)
+ uri = URI.parse(url)
+ params = URI.decode_www_form(uri.query || "").to_h
+ params["to"]&.to_i
+ end
+
+ def parse_attack(data)
+ modifiers = data["modifiers"] || {}
+
+ Attack.new(
+ id: data["id"],
+ code: data["code"],
+ started: data["started"],
+ ended: data["ended"],
+ attacker_id: data.dig("attacker", "id"),
+ attacker_name: data.dig("attacker", "name"),
+ attacker_level: data.dig("attacker", "level"),
+ attacker_faction_id: data.dig("attacker", "faction", "id"),
+ attacker_faction_name: data.dig("attacker", "faction", "name"),
+ defender_id: data.dig("defender", "id"),
+ defender_name: data.dig("defender", "name"),
+ defender_level: data.dig("defender", "level"),
+ defender_faction_id: data.dig("defender", "faction", "id"),
+ defender_faction_name: data.dig("defender", "faction", "name"),
+ result: data["result"],
+ respect_gain: data["respect_gain"],
+ respect_loss: data["respect_loss"],
+ chain: data["chain"],
+ is_ranked_war: data["is_ranked_war"],
+ is_stealthed: data["is_stealthed"],
+ is_interrupted: data["is_interrupted"],
+ is_raid: data["is_raid"],
+ fair_fight: modifiers["fair_fight"],
+ war: modifiers["war"],
+ retaliation: modifiers["retaliation"],
+ group: modifiers["group"],
+ overseas: modifiers["overseas"],
+ chain_modifier: modifiers["chain"],
+ warlord: modifiers["warlord"],
+ finishing_hit_effects: data["finishing_hit_effects"] || []
+ )
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/faction/basic.rb b/app/models/torn_api/faction/basic.rb
new file mode 100644
index 0000000..20e6686
--- /dev/null
+++ b/app/models/torn_api/faction/basic.rb
@@ -0,0 +1,29 @@
+module TornApi
+ module Faction
+ class Basic < Base
+ attr_reader :torn_id
+
+ def initialize(api_key, torn_id)
+ super(api_key)
+ @torn_id = torn_id
+ end
+
+ def endpoint
+ "v2/faction/#{@torn_id}"
+ end
+
+ def fetch
+ response = get(endpoint)
+ if response["basic"].present?
+ response["basic"]
+ else
+ raise ApiError, "No faction data returned: #{response}"
+ end
+ end
+
+ def name
+ fetch["name"]
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/faction/members.rb b/app/models/torn_api/faction/members.rb
index a2f43f5..b8a93eb 100644
--- a/app/models/torn_api/faction/members.rb
+++ b/app/models/torn_api/faction/members.rb
@@ -15,6 +15,7 @@ class Members < Base
:status_state,
:status_color,
:status_until,
+ :plane_image_type,
:revive_setting,
:position,
:is_revivable,
@@ -33,11 +34,12 @@ def endpoint
end
def fetch
- response = get(endpoint, striptags: false)
+ params = { striptags: false, timestamp: Time.current.to_i }
+ response = get(endpoint, params)
if response["members"].present?
parse(response["members"])
else
- raise InvalidKeyError, "Torn API authentication failed: #{response}"
+ raise ApiError, "No members data returned: #{response}"
end
end
@@ -58,6 +60,7 @@ def parse(members_array)
member.dig("status", "state"),
member.dig("status", "color"),
member.dig("status", "until"),
+ member.dig("status", "plane_image_type"),
member["revive_setting"],
member["position"],
member["is_revivable"],
diff --git a/app/models/torn_api/faction/ranked_war_report.rb b/app/models/torn_api/faction/ranked_war_report.rb
new file mode 100644
index 0000000..978c875
--- /dev/null
+++ b/app/models/torn_api/faction/ranked_war_report.rb
@@ -0,0 +1,21 @@
+module TornApi
+ module Faction
+ class RankedWarReport < Base
+ attr_reader :war_id
+
+ def initialize(api_key, war_id)
+ super(api_key)
+ @war_id = war_id
+ end
+
+ def endpoint
+ "v2/faction/#{war_id}/rankedwarreport"
+ end
+
+ def fetch
+ response = get(endpoint)
+ response["rankedwarreport"]
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/faction/ranked_wars.rb b/app/models/torn_api/faction/ranked_wars.rb
new file mode 100644
index 0000000..ca5b076
--- /dev/null
+++ b/app/models/torn_api/faction/ranked_wars.rb
@@ -0,0 +1,42 @@
+module TornApi
+ module Faction
+ class RankedWars < Base
+ attr_reader :faction_id
+
+ def initialize(api_key, faction_id = nil)
+ super(api_key)
+ @faction_id = faction_id
+ end
+
+ def endpoint
+ if faction_id
+ "v2/faction/#{faction_id}/rankedwars"
+ else
+ "v2/faction/rankedwars"
+ end
+ end
+
+ def fetch(limit: 20, offset: 0, sort: "DESC")
+ response = get(endpoint, { limit: limit, offset: offset, sort: sort })
+ response["rankedwars"] || []
+ end
+
+ def fetch_all
+ all_wars = []
+ offset = 0
+ limit = 100
+
+ loop do
+ wars = fetch(limit: limit, offset: offset)
+ break if wars.empty?
+
+ all_wars.concat(wars)
+ offset += limit
+ break if offset > 1000
+ end
+
+ all_wars
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/key/info.rb b/app/models/torn_api/key/info.rb
new file mode 100644
index 0000000..39a2b31
--- /dev/null
+++ b/app/models/torn_api/key/info.rb
@@ -0,0 +1,49 @@
+module TornApi
+ module Key
+ class Info < TornApi::Base
+ AccessData = Data.define(
+ :level,
+ :type,
+ :faction,
+ :company
+ )
+
+ UserData = Data.define(
+ :id,
+ :faction_id,
+ :company_id
+ )
+
+ InfoData = Data.define(
+ :access,
+ :user
+ )
+
+ def fetch
+ data = get("v2/key/info")
+
+ raise TornApi::InvalidKeyError if data["error"]
+
+ info_data = data["info"]
+
+ access = AccessData.new(
+ level: info_data.dig("access", "level"),
+ type: info_data.dig("access", "type"),
+ faction: info_data.dig("access", "faction"),
+ company: info_data.dig("access", "company")
+ )
+
+ user = UserData.new(
+ id: info_data.dig("user", "id"),
+ faction_id: info_data.dig("user", "faction_id"),
+ company_id: info_data.dig("user", "company_id")
+ )
+
+ InfoData.new(
+ access: access,
+ user: user
+ )
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/key/log.rb b/app/models/torn_api/key/log.rb
new file mode 100644
index 0000000..9b75fbe
--- /dev/null
+++ b/app/models/torn_api/key/log.rb
@@ -0,0 +1,47 @@
+module TornApi
+ module Key
+ class Log < TornApi::Base
+ LogEntry = Data.define(
+ :timestamp,
+ :type,
+ :selections,
+ :id,
+ :ip,
+ :comment
+ )
+
+ LogData = Data.define(
+ :log,
+ :_metadata
+ )
+
+ def fetch
+ all_entries = []
+
+ [ 0, 100, 200 ].each do |offset|
+ data = get("v2/key/log", { limit: 100, offset: offset })
+
+ raise TornApi::InvalidKeyError if data["error"]
+
+ batch_entries = data["log"].map do |entry|
+ LogEntry.new(
+ timestamp: entry["timestamp"],
+ type: entry["type"],
+ selections: entry["selections"],
+ id: entry["id"],
+ ip: entry["ip"],
+ comment: entry["comment"]
+ )
+ end
+
+ all_entries.concat(batch_entries)
+ end
+
+ LogData.new(
+ log: all_entries,
+ _metadata: nil
+ )
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/market.rb b/app/models/torn_api/market.rb
index 12c5448..e1a5ebb 100644
--- a/app/models/torn_api/market.rb
+++ b/app/models/torn_api/market.rb
@@ -3,11 +3,11 @@ class Market < Base
ENDPOINT = "v2/market".freeze
def fetch
- response = get(ENDPOINT, striptags: false, selections: "pointsmarket")
+ response = get(ENDPOINT, { striptags: false, selections: "pointsmarket" })
if response["pointsmarket"].present?
response["pointsmarket"]
else
- raise InvalidKeyError, "Torn API authentication failed: #{response}"
+ raise ApiError, "No market data returned: #{response}"
end
end
end
diff --git a/app/models/torn_api/rate_limiter.rb b/app/models/torn_api/rate_limiter.rb
new file mode 100644
index 0000000..afef2d1
--- /dev/null
+++ b/app/models/torn_api/rate_limiter.rb
@@ -0,0 +1,72 @@
+module TornApi
+ # Client-side request budget, enforced before any HTTP happens. Torn allows
+ # 100 requests/minute per player across all their keys; we budget half per
+ # key plus a global cap per server IP, shared across processes via Rails.cache.
+ class RateLimiter
+ TORN_HARD_LIMIT = 100
+ REQUESTS_PER_MINUTE = TORN_HARD_LIMIT / 2
+ GLOBAL_REQUESTS_PER_MINUTE = 300
+ WINDOW_SECONDS = 60
+
+ # Background jobs leave the top 15% of each key's budget for live web traffic.
+ BACKGROUND_RESERVE = 0.15
+ BACKGROUND_REQUESTS_PER_MINUTE = (REQUESTS_PER_MINUTE * (1 - BACKGROUND_RESERVE)).floor
+
+ class << self
+ def reserving_headroom_for_live_traffic
+ prior = Thread.current[:torn_api_reserve_headroom]
+ Thread.current[:torn_api_reserve_headroom] = true
+ yield
+ ensure
+ Thread.current[:torn_api_reserve_headroom] = prior
+ end
+
+ def acquire!(api_key)
+ limit = reserving_headroom? ? BACKGROUND_REQUESTS_PER_MINUTE : REQUESTS_PER_MINUTE
+
+ key_count = increment(key_window(api_key))
+ if key_count > limit
+ raise RateLimitError, "Too many requests (client-side key budget of #{limit}/min spent)"
+ end
+
+ global_count = increment(global_window)
+ if global_count > GLOBAL_REQUESTS_PER_MINUTE
+ raise RateLimitError, "Too many requests (client-side global budget of #{GLOBAL_REQUESTS_PER_MINUTE}/min spent)"
+ end
+
+ true
+ end
+
+ def remaining(api_key)
+ [ REQUESTS_PER_MINUTE - current(key_window(api_key)), 0 ].max
+ end
+
+ private
+
+ def reserving_headroom?
+ Thread.current[:torn_api_reserve_headroom] == true
+ end
+
+ # Null cache stores (test default) return nil; treat as unlimited.
+ def increment(cache_key)
+ Rails.cache.increment(cache_key, 1, expires_in: WINDOW_SECONDS * 2) || 1
+ end
+
+ def current(cache_key)
+ Rails.cache.read(cache_key, raw: true).to_i
+ end
+
+ def key_window(api_key)
+ "torn_api_budget:#{window_stamp}:#{api_key}"
+ end
+
+ def global_window
+ "torn_api_budget:#{window_stamp}:global"
+ end
+
+ def window_stamp
+ Time.current.to_i / WINDOW_SECONDS
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/torn/factionhof.rb b/app/models/torn_api/torn/factionhof.rb
index def2643..70151e2 100644
--- a/app/models/torn_api/torn/factionhof.rb
+++ b/app/models/torn_api/torn/factionhof.rb
@@ -21,11 +21,11 @@ def endpoint
end
def fetch
- response = get(endpoint, limit: @limit, offset: @offset, cat: "respect", striptags: false)
+ response = get(endpoint, { limit: @limit, offset: @offset, cat: "respect", striptags: false })
if response["factionhof"].present?
parse(response["factionhof"])
else
- raise InvalidKeyError, "Torn API authentication failed: #{response}"
+ raise ApiError, "No faction HOF data returned: #{response}"
end
end
diff --git a/app/models/torn_api/torn/item_details.rb b/app/models/torn_api/torn/item_details.rb
new file mode 100644
index 0000000..a6fb04b
--- /dev/null
+++ b/app/models/torn_api/torn/item_details.rb
@@ -0,0 +1,37 @@
+module TornApi
+ module Torn
+ class ItemDetails < Base
+ def initialize(api_key, uid)
+ super(api_key)
+ @uid = uid
+ end
+
+ def endpoint
+ "v2/torn/#{@uid}/itemdetails"
+ end
+
+ def fetch
+ response = get(endpoint, { striptags: false })
+ parse(response["itemdetails"])
+ end
+
+ private
+
+ def parse(details)
+ return nil unless details
+
+ stats = details["stats"] || {}
+ {
+ id: details["id"],
+ name: details["name"],
+ damage: stats["damage"],
+ accuracy: stats["accuracy"],
+ armor: stats["armor"],
+ quality: stats["quality"],
+ rarity: details["rarity"],
+ bonuses: details["bonuses"] || []
+ }
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/torn/items.rb b/app/models/torn_api/torn/items.rb
index e561a65..f772312 100644
--- a/app/models/torn_api/torn/items.rb
+++ b/app/models/torn_api/torn/items.rb
@@ -4,11 +4,11 @@ class Items < Base
ENDPOINT = "v2/torn/items".freeze
def fetch
- response = get(ENDPOINT, striptags: false)
+ response = get(ENDPOINT, { striptags: false })
if response["items"].present?
build_items(response["items"])
else
- raise InvalidKeyError, "Torn API authentication failed: #{response}"
+ raise ApiError, "No items data returned: #{response}"
end
end
diff --git a/app/models/torn_api/torn/stocks.rb b/app/models/torn_api/torn/stocks.rb
index dd124bc..fc17c36 100644
--- a/app/models/torn_api/torn/stocks.rb
+++ b/app/models/torn_api/torn/stocks.rb
@@ -4,26 +4,26 @@ class Stocks < Base
ENDPOINT = "v2/torn/stocks".freeze
def fetch
- response = get(ENDPOINT, striptags: false)
+ response = get(ENDPOINT, { striptags: false })
if response["stocks"].present?
build_stocks(response["stocks"])
else
- raise InvalidKeyError, "Torn API authentication failed: #{response}"
+ raise ApiError, "No stocks data returned: #{response}"
end
end
private
def build_stocks(data)
- data.map do |_, details|
+ data.map do |details|
::Torn::Stock.new(
- torn_id: details["stock_id"],
+ torn_id: details["id"],
name: details["name"],
acronym: details["acronym"],
- current_price: details["current_price"],
- dividend_frequency: details["benefit"]["frequency"],
- dividend_requirement: details["benefit"]["requirement"],
- dividend_description: details["benefit"]["description"],
+ current_price: details.dig("market", "price"),
+ dividend_frequency: details.dig("bonus", "frequency"),
+ dividend_requirement: details.dig("bonus", "requirement"),
+ dividend_description: details.dig("bonus", "description"),
)
end
end
diff --git a/app/models/torn_api/user/basic.rb b/app/models/torn_api/user/basic.rb
new file mode 100644
index 0000000..3c6c69e
--- /dev/null
+++ b/app/models/torn_api/user/basic.rb
@@ -0,0 +1,49 @@
+module TornApi
+ module User
+ class Basic < Base
+ attr_reader :torn_id
+
+ BasicData = Data.define(
+ :id,
+ :name,
+ :level,
+ :gender,
+ :status
+ )
+
+ def initialize(api_key, torn_id = nil)
+ super(api_key)
+ @torn_id = torn_id
+ end
+
+ def endpoint
+ if torn_id
+ "v2/user/#{torn_id}/basic"
+ else
+ "v2/user/basic"
+ end
+ end
+
+ def fetch
+ response = get(endpoint, { striptags: true })
+ if response["profile"].present?
+ parse_profile(response["profile"])
+ else
+ raise ApiError, "No user data returned: #{response}"
+ end
+ end
+
+ private
+
+ def parse_profile(data)
+ BasicData.new(
+ id: data["id"],
+ name: data["name"],
+ level: data["level"],
+ gender: data["gender"],
+ status: data["status"]
+ )
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/user/discord.rb b/app/models/torn_api/user/discord.rb
new file mode 100644
index 0000000..f47c1a6
--- /dev/null
+++ b/app/models/torn_api/user/discord.rb
@@ -0,0 +1,28 @@
+module TornApi
+ module User
+ class Discord < Base
+ DiscordData = Data.define(:discord_id, :user_id)
+
+ attr_reader :lookup_id
+
+ def initialize(api_key, lookup_id)
+ super(api_key)
+ @lookup_id = lookup_id
+ end
+
+ def fetch
+ response = get("v2/user/#{lookup_id}/discord")
+ discord = response["discord"]
+
+ return nil unless discord && discord["user_id"]
+
+ DiscordData.new(
+ discord_id: discord["discord_id"],
+ user_id: discord["user_id"]
+ )
+ rescue TornApi::NotFoundError
+ nil
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/user/log.rb b/app/models/torn_api/user/log.rb
new file mode 100644
index 0000000..389e05f
--- /dev/null
+++ b/app/models/torn_api/user/log.rb
@@ -0,0 +1,61 @@
+module TornApi
+ module User
+ class Log < Base
+ ENDPOINT = "v2/user/log".freeze
+ XANAX_ITEM_ID = 206
+
+ LogEntry = Data.define(
+ :id,
+ :timestamp,
+ :sender_torn_id,
+ :xanax_quantity
+ )
+
+ def fetch_xanax_payments(limit: 100)
+ response = get(ENDPOINT, { log: 4103, limit: limit })
+ response["log"].present? ? parse_logs(response["log"]) : []
+ end
+
+ private
+
+ def parse_logs(logs)
+ logs.filter_map do |log|
+ next unless contains_xanax?(log)
+
+ LogEntry.new(
+ id: log["id"],
+ timestamp: log["timestamp"],
+ sender_torn_id: log["data"]["sender"],
+ xanax_quantity: extract_xanax_quantity(log["data"]["items"])
+ )
+ end
+ end
+
+ def contains_xanax?(log)
+ return false unless log["data"]&.[]("items")
+ items = log["data"]["items"]
+
+ case items
+ when Array
+ items.any? { |item| item.is_a?(Hash) && item["id"] == XANAX_ITEM_ID }
+ when Hash
+ items.key?(XANAX_ITEM_ID.to_s)
+ else
+ false
+ end
+ end
+
+ def extract_xanax_quantity(items)
+ case items
+ when Array
+ xanax_item = items.find { |item| item.is_a?(Hash) && item["id"] == XANAX_ITEM_ID }
+ xanax_item&.[]("qty") || 0
+ when Hash
+ items[XANAX_ITEM_ID.to_s].to_i
+ else
+ 0
+ end
+ end
+ end
+ end
+end
diff --git a/app/models/torn_api/user/personal_stats.rb b/app/models/torn_api/user/personal_stats.rb
index 73661ff..959a19b 100644
--- a/app/models/torn_api/user/personal_stats.rb
+++ b/app/models/torn_api/user/personal_stats.rb
@@ -1,222 +1,13 @@
module TornApi
module User
class PersonalStats < Base
- attr_reader :torn_id
- PersonalStatSnapshot = Data.define(
- :attacking_attacks_won,
- :attacking_attacks_lost,
- :attacking_attacks_stalemate,
- :attacking_attacks_assist,
- :attacking_attacks_stealth,
- :attacking_defends_won,
- :attacking_defends_lost,
- :attacking_defends_stalemate,
- :attacking_defends_total,
- :attacking_elo,
- :attacking_unarmored_wins,
- :attacking_highest_level_beaten,
- :attacking_escapes_player,
- :attacking_escapes_foes,
- :attacking_killstreak_best,
- :attacking_hits_success,
- :attacking_hits_miss,
- :attacking_hits_critical,
- :attacking_hits_one_hit_kills,
- :attacking_damage_total,
- :attacking_damage_best,
- :attacking_networth_money_mugged,
- :attacking_networth_largest_mug,
- :attacking_networth_items_looted,
- :attacking_ammunition_total,
- :attacking_ammunition_special,
- :attacking_ammunition_hollow_point,
- :attacking_ammunition_tracer,
- :attacking_ammunition_piercing,
- :attacking_ammunition_incendiary,
- :attacking_faction_respect,
- :attacking_faction_retaliations,
- :attacking_faction_ranked_war_hits,
- :attacking_faction_raid_hits,
- :attacking_faction_territory_wall_joins,
- :attacking_faction_territory_wall_clears,
- :attacking_faction_territory_wall_time,
+ attr_reader :torn_id, :timestamp, :stat_batch
- # Jobs
- :jobs_job_points_used,
- :jobs_trains_received,
-
- # Trading
- :trading_items_bought_market,
- :trading_items_bought_shops,
- :trading_items_auctions_won,
- :trading_items_auctions_sold,
- :trading_items_sent,
- :trading_trades,
- :trading_points_bought,
- :trading_points_sold,
- :trading_bazaar_customers,
- :trading_bazaar_sales,
- :trading_bazaar_profit,
- :trading_item_market_customers,
- :trading_item_market_sales,
- :trading_item_market_revenue,
- :trading_item_market_fees,
-
- # Jail
- :jail_times_jailed,
- :jail_busts_success,
- :jail_busts_fails,
- :jail_bails_amount,
- :jail_bails_fees,
-
- # Hospital
- :hospital_times_hospitalized,
- :hospital_medical_items_used,
- :hospital_blood_withdrawn,
- :hospital_reviving_skill,
- :hospital_reviving_revives,
- :hospital_reviving_revives_received,
-
- # Finishing hits
- :finishing_hits_heavy_artillery,
- :finishing_hits_machine_guns,
- :finishing_hits_rifles,
- :finishing_hits_sub_machine_guns,
- :finishing_hits_shotguns,
- :finishing_hits_pistols,
- :finishing_hits_temporary,
- :finishing_hits_piercing,
- :finishing_hits_slashing,
- :finishing_hits_clubbing,
- :finishing_hits_mechanical,
- :finishing_hits_hand_to_hand,
-
- # Communication
- :communication_mails_sent_total,
- :communication_mails_sent_friends,
- :communication_mails_sent_faction,
- :communication_mails_sent_colleagues,
- :communication_mails_sent_spouse,
- :communication_classified_ads,
- :communication_personals,
-
- # Crimes
- :crimes_offenses_vandalism,
- :crimes_offenses_fraud,
- :crimes_offenses_theft,
- :crimes_offenses_counterfeiting,
- :crimes_offenses_illicit_services,
- :crimes_offenses_cybercrime,
- :crimes_offenses_extortion,
- :crimes_offenses_illegal_production,
- :crimes_offenses_organized_crimes,
- :crimes_offenses_total,
- :crimes_skills_search_for_cash,
- :crimes_skills_bootlegging,
- :crimes_skills_graffiti,
- :crimes_skills_shoplifting,
- :crimes_skills_pickpocketing,
- :crimes_skills_card_skimming,
- :crimes_skills_burglary,
- :crimes_skills_hustling,
- :crimes_skills_disposal,
- :crimes_skills_cracking,
- :crimes_skills_forgery,
- :crimes_skills_scamming,
- :crimes_skills_arson,
- :crimes_total,
- :crimes_version,
-
- # Bounties
- :bounties_placed_amount,
- :bounties_placed_value,
- :bounties_collected_amount,
- :bounties_collected_value,
- :bounties_received_amount,
- :bounties_received_value,
-
- # Items
- :items_found_city,
- :items_found_dump,
- :items_found_easter_eggs,
- :items_trashed,
- :items_used_books,
- :items_used_boosters,
- :items_used_consumables,
- :items_used_candy,
- :items_used_alcohol,
- :items_used_energy,
- :items_used_energy_drinks,
- :items_used_stat_enhancers,
- :items_used_easter_eggs,
- :items_viruses_coded,
-
- # Travel
- :travel_total,
- :travel_time_spent,
- :travel_items_bought,
- :travel_hunting_skill,
- :travel_attacks_won,
- :travel_defends_lost,
- :travel_argentina,
- :travel_canada,
- :travel_cayman_islands,
- :travel_china,
- :travel_hawaii,
- :travel_japan,
- :travel_mexico,
- :travel_united_arab_emirates,
- :travel_united_kingdom,
- :travel_south_africa,
- :travel_switzerland,
-
- # Drugs
- :drugs_cannabis,
- :drugs_ecstasy,
- :drugs_ketamine,
- :drugs_lsd,
- :drugs_opium,
- :drugs_pcp,
- :drugs_shrooms,
- :drugs_speed,
- :drugs_vicodin,
- :drugs_xanax,
- :drugs_total,
- :drugs_overdoses,
- :drugs_rehabilitations_amount,
- :drugs_rehabilitations_fees,
-
- # Missions
- :missions_missions,
- :missions_contracts_total,
- :missions_contracts_duke,
- :missions_credits,
-
- # Racing
- :racing_skill,
- :racing_points,
- :racing_races_entered,
- :racing_races_won,
-
- # Networth
- :networth_total,
-
- # Other
- :other_activity_time,
- :other_activity_streak_current,
- :other_activity_streak_best,
- :other_awards,
- :other_merits_bought,
- :other_refills_energy,
- :other_refills_nerve,
- :other_refills_token,
- :other_donator_days,
- :other_ranked_war_wins
- )
-
- def initialize(api_key, torn_id)
+ def initialize(api_key, torn_id, timestamp: nil, stat_batch: nil)
super(api_key)
@torn_id = torn_id
+ @timestamp = timestamp
+ @stat_batch = stat_batch || ::PersonalStatSnapshot::TRACKED_STATS
end
def endpoint
@@ -224,229 +15,36 @@ def endpoint
end
def fetch
- response = get(endpoint, cat: "all", striptags: false)
- if response["personalstats"].present?
- parse_personalstats(response["personalstats"])
+ stat_names = stat_batch.keys.join(",")
+ params = { stat: stat_names }
+ params[:timestamp] = timestamp if timestamp
+
+ response = get(endpoint, params)
+
+ if response["personalstats"].present? || response["personalstats"].is_a?(Array)
+ parse_personalstats(response["personalstats"], stat_batch)
else
- raise InvalidKeyError, "Torn API authentication failed: #{response}"
+ raise NoDataError, "No personal stats data returned: #{response}"
end
end
private
- def parse_personalstats(stats)
- PersonalStatSnapshot.new(
- # Attacking
- attacking_attacks_won: stats.dig("attacking", "attacks", "won"),
- attacking_attacks_lost: stats.dig("attacking", "attacks", "lost"),
- attacking_attacks_stalemate: stats.dig("attacking", "attacks", "stalemate"),
- attacking_attacks_assist: stats.dig("attacking", "attacks", "assist"),
- attacking_attacks_stealth: stats.dig("attacking", "attacks", "stealth"),
- attacking_defends_won: stats.dig("attacking", "defends", "won"),
- attacking_defends_lost: stats.dig("attacking", "defends", "lost"),
- attacking_defends_stalemate: stats.dig("attacking", "defends", "stalemate"),
- attacking_defends_total: stats.dig("attacking", "defends", "total"),
- attacking_elo: stats.dig("attacking", "elo"),
- attacking_unarmored_wins: stats.dig("attacking", "unarmored_wins"),
- attacking_highest_level_beaten: stats.dig("attacking", "highest_level_beaten"),
- attacking_escapes_player: stats.dig("attacking", "escapes", "player"),
- attacking_escapes_foes: stats.dig("attacking", "escapes", "foes"),
- attacking_killstreak_best: stats.dig("attacking", "killstreak", "best"),
- attacking_hits_success: stats.dig("attacking", "hits", "success"),
- attacking_hits_miss: stats.dig("attacking", "hits", "miss"),
- attacking_hits_critical: stats.dig("attacking", "hits", "critical"),
- attacking_hits_one_hit_kills: stats.dig("attacking", "hits", "one_hit_kills"),
- attacking_damage_total: stats.dig("attacking", "damage", "total"),
- attacking_damage_best: stats.dig("attacking", "damage", "best"),
- attacking_networth_money_mugged: stats.dig("attacking", "networth", "money_mugged"),
- attacking_networth_largest_mug: stats.dig("attacking", "networth", "largest_mug"),
- attacking_networth_items_looted: stats.dig("attacking", "networth", "items_looted"),
- attacking_ammunition_total: stats.dig("attacking", "ammunition", "total"),
- attacking_ammunition_special: stats.dig("attacking", "ammunition", "special"),
- attacking_ammunition_hollow_point: stats.dig("attacking", "ammunition", "hollow_point"),
- attacking_ammunition_tracer: stats.dig("attacking", "ammunition", "tracer"),
- attacking_ammunition_piercing: stats.dig("attacking", "ammunition", "piercing"),
- attacking_ammunition_incendiary: stats.dig("attacking", "ammunition", "incendiary"),
- attacking_faction_respect: stats.dig("attacking", "faction", "respect"),
- attacking_faction_retaliations: stats.dig("attacking", "faction", "retaliations"),
- attacking_faction_ranked_war_hits: stats.dig("attacking", "faction", "ranked_war_hits"),
- attacking_faction_raid_hits: stats.dig("attacking", "faction", "raid_hits"),
- attacking_faction_territory_wall_joins: stats.dig("attacking", "faction", "territory", "wall_joins"),
- attacking_faction_territory_wall_clears: stats.dig("attacking", "faction", "territory", "wall_clears"),
- attacking_faction_territory_wall_time: stats.dig("attacking", "faction", "territory", "wall_time"),
-
- # Jobs
- jobs_job_points_used: stats.dig("jobs", "job_points_used"),
- jobs_trains_received: stats.dig("jobs", "trains_received"),
-
- # Trading
- trading_items_bought_market: stats.dig("trading", "items", "bought", "market"),
- trading_items_bought_shops: stats.dig("trading", "items", "bought", "shops"),
- trading_items_auctions_won: stats.dig("trading", "items", "auctions", "won"),
- trading_items_auctions_sold: stats.dig("trading", "items", "auctions", "sold"),
- trading_items_sent: stats.dig("trading", "items", "sent"),
- trading_trades: stats.dig("trading", "trades"),
- trading_points_bought: stats.dig("trading", "points", "bought"),
- trading_points_sold: stats.dig("trading", "points", "sold"),
- trading_bazaar_customers: stats.dig("trading", "bazaar", "customers"),
- trading_bazaar_sales: stats.dig("trading", "bazaar", "sales"),
- trading_bazaar_profit: stats.dig("trading", "bazaar", "profit"),
- trading_item_market_customers: stats.dig("trading", "item_market", "customers"),
- trading_item_market_sales: stats.dig("trading", "item_market", "sales"),
- trading_item_market_revenue: stats.dig("trading", "item_market", "revenue"),
- trading_item_market_fees: stats.dig("trading", "item_market", "fees"),
-
- # Jail
- jail_times_jailed: stats.dig("jail", "times_jailed"),
- jail_busts_success: stats.dig("jail", "busts", "success"),
- jail_busts_fails: stats.dig("jail", "busts", "fails"),
- jail_bails_amount: stats.dig("jail", "bails", "amount"),
- jail_bails_fees: stats.dig("jail", "bails", "fees"),
-
- # Hospital
- hospital_times_hospitalized: stats.dig("hospital", "times_hospitalized"),
- hospital_medical_items_used: stats.dig("hospital", "medical_items_used"),
- hospital_blood_withdrawn: stats.dig("hospital", "blood_withdrawn"),
- hospital_reviving_skill: stats.dig("hospital", "reviving", "skill"),
- hospital_reviving_revives: stats.dig("hospital", "reviving", "revives"),
- hospital_reviving_revives_received: stats.dig("hospital", "reviving", "revives_received"),
-
- # Finishing hits
- finishing_hits_heavy_artillery: stats.dig("finishing_hits", "heavy_artillery"),
- finishing_hits_machine_guns: stats.dig("finishing_hits", "machine_guns"),
- finishing_hits_rifles: stats.dig("finishing_hits", "rifles"),
- finishing_hits_sub_machine_guns: stats.dig("finishing_hits", "sub_machine_guns"),
- finishing_hits_shotguns: stats.dig("finishing_hits", "shotguns"),
- finishing_hits_pistols: stats.dig("finishing_hits", "pistols"),
- finishing_hits_temporary: stats.dig("finishing_hits", "temporary"),
- finishing_hits_piercing: stats.dig("finishing_hits", "piercing"),
- finishing_hits_slashing: stats.dig("finishing_hits", "slashing"),
- finishing_hits_clubbing: stats.dig("finishing_hits", "clubbing"),
- finishing_hits_mechanical: stats.dig("finishing_hits", "mechanical"),
- finishing_hits_hand_to_hand: stats.dig("finishing_hits", "hand_to_hand"),
-
- # Communication
- communication_mails_sent_total: stats.dig("communication", "mails_sent", "total"),
- communication_mails_sent_friends: stats.dig("communication", "mails_sent", "friends"),
- communication_mails_sent_faction: stats.dig("communication", "mails_sent", "faction"),
- communication_mails_sent_colleagues: stats.dig("communication", "mails_sent", "colleagues"),
- communication_mails_sent_spouse: stats.dig("communication", "mails_sent", "spouse"),
- communication_classified_ads: stats.dig("communication", "classified_ads"),
- communication_personals: stats.dig("communication", "personals"),
-
- # Crimes
- crimes_offenses_vandalism: stats.dig("crimes", "offenses", "vandalism"),
- crimes_offenses_fraud: stats.dig("crimes", "offenses", "fraud"),
- crimes_offenses_theft: stats.dig("crimes", "offenses", "theft"),
- crimes_offenses_counterfeiting: stats.dig("crimes", "offenses", "counterfeiting"),
- crimes_offenses_illicit_services: stats.dig("crimes", "offenses", "illicit_services"),
- crimes_offenses_cybercrime: stats.dig("crimes", "offenses", "cybercrime"),
- crimes_offenses_extortion: stats.dig("crimes", "offenses", "extortion"),
- crimes_offenses_illegal_production: stats.dig("crimes", "offenses", "illegal_production"),
- crimes_offenses_organized_crimes: stats.dig("crimes", "offenses", "organized_crimes"),
- crimes_offenses_total: stats.dig("crimes", "offenses", "total"),
- crimes_skills_search_for_cash: stats.dig("crimes", "skills", "search_for_cash"),
- crimes_skills_bootlegging: stats.dig("crimes", "skills", "bootlegging"),
- crimes_skills_graffiti: stats.dig("crimes", "skills", "graffiti"),
- crimes_skills_shoplifting: stats.dig("crimes", "skills", "shoplifting"),
- crimes_skills_pickpocketing: stats.dig("crimes", "skills", "pickpocketing"),
- crimes_skills_card_skimming: stats.dig("crimes", "skills", "card_skimming"),
- crimes_skills_burglary: stats.dig("crimes", "skills", "burglary"),
- crimes_skills_hustling: stats.dig("crimes", "skills", "hustling"),
- crimes_skills_disposal: stats.dig("crimes", "skills", "disposal"),
- crimes_skills_cracking: stats.dig("crimes", "skills", "cracking"),
- crimes_skills_forgery: stats.dig("crimes", "skills", "forgery"),
- crimes_skills_scamming: stats.dig("crimes", "skills", "scamming"),
- crimes_skills_arson: stats.dig("crimes", "skills", "arson"),
- crimes_total: stats.dig("crimes", "total"),
- crimes_version: stats.dig("crimes", "version"),
-
- # Bounties
- bounties_placed_amount: stats.dig("bounties", "placed", "amount"),
- bounties_placed_value: stats.dig("bounties", "placed", "value"),
- bounties_collected_amount: stats.dig("bounties", "collected", "amount"),
- bounties_collected_value: stats.dig("bounties", "collected", "value"),
- bounties_received_amount: stats.dig("bounties", "received", "amount"),
- bounties_received_value: stats.dig("bounties", "received", "value"),
-
- # Items
- items_found_city: stats.dig("items", "found", "city"),
- items_found_dump: stats.dig("items", "found", "dump"),
- items_found_easter_eggs: stats.dig("items", "found", "easter_eggs"),
- items_trashed: stats.dig("items", "trashed"),
- items_used_books: stats.dig("items", "used", "books"),
- items_used_boosters: stats.dig("items", "used", "boosters"),
- items_used_consumables: stats.dig("items", "used", "consumables"),
- items_used_candy: stats.dig("items", "used", "candy"),
- items_used_alcohol: stats.dig("items", "used", "alcohol"),
- items_used_energy: stats.dig("items", "used", "energy"),
- items_used_energy_drinks: stats.dig("items", "used", "energy_drinks"),
- items_used_stat_enhancers: stats.dig("items", "used", "stat_enhancers"),
- items_used_easter_eggs: stats.dig("items", "used", "easter_eggs"),
- items_viruses_coded: stats.dig("items", "viruses_coded"),
-
- # Travel
- travel_total: stats.dig("travel", "total"),
- travel_time_spent: stats.dig("travel", "time_spent"),
- travel_items_bought: stats.dig("travel", "items_bought"),
- travel_hunting_skill: stats.dig("travel", "hunting", "skill"),
- travel_attacks_won: stats.dig("travel", "attacks_won"),
- travel_defends_lost: stats.dig("travel", "defends_lost"),
- travel_argentina: stats.dig("travel", "argentina"),
- travel_canada: stats.dig("travel", "canada"),
- travel_cayman_islands: stats.dig("travel", "cayman_islands"),
- travel_china: stats.dig("travel", "china"),
- travel_hawaii: stats.dig("travel", "hawaii"),
- travel_japan: stats.dig("travel", "japan"),
- travel_mexico: stats.dig("travel", "mexico"),
- travel_united_arab_emirates: stats.dig("travel", "united_arab_emirates"),
- travel_united_kingdom: stats.dig("travel", "united_kingdom"),
- travel_south_africa: stats.dig("travel", "south_africa"),
- travel_switzerland: stats.dig("travel", "switzerland"),
-
- # Drugs
- drugs_cannabis: stats.dig("drugs", "cannabis"),
- drugs_ecstasy: stats.dig("drugs", "ecstasy"),
- drugs_ketamine: stats.dig("drugs", "ketamine"),
- drugs_lsd: stats.dig("drugs", "lsd"),
- drugs_opium: stats.dig("drugs", "opium"),
- drugs_pcp: stats.dig("drugs", "pcp"),
- drugs_shrooms: stats.dig("drugs", "shrooms"),
- drugs_speed: stats.dig("drugs", "speed"),
- drugs_vicodin: stats.dig("drugs", "vicodin"),
- drugs_xanax: stats.dig("drugs", "xanax"),
- drugs_total: stats.dig("drugs", "total"),
- drugs_overdoses: stats.dig("drugs", "overdoses"),
- drugs_rehabilitations_amount: stats.dig("drugs", "rehabilitations", "amount"),
- drugs_rehabilitations_fees: stats.dig("drugs", "rehabilitations", "fees"),
+ def parse_personalstats(stats, requested_stats)
+ stats_hash = stats.each_with_object({}) do |stat, hash|
+ hash[stat["name"]] = stat["value"]
+ end
- # Missions
- missions_missions: stats.dig("missions", "missions"),
- missions_contracts_total: stats.dig("missions", "contracts", "total"),
- missions_contracts_duke: stats.dig("missions", "contracts", "duke"),
- missions_credits: stats.dig("missions", "credits"),
+ response_timestamp = stats.first&.dig("timestamp")
+ response_date = response_timestamp ? Time.at(response_timestamp).utc.to_date : nil
- # Racing
- racing_skill: stats.dig("racing", "skill"),
- racing_points: stats.dig("racing", "points"),
- racing_races_entered: stats.dig("racing", "races", "entered"),
- racing_races_won: stats.dig("racing", "races", "won"),
+ result = { date: response_date, timestamp: response_timestamp }
- # Networth
- networth_total: stats.dig("networth", "total"),
+ requested_stats.each do |api_name, db_column|
+ result[db_column] = stats_hash[api_name] || 0
+ end
- # Other
- other_activity_time: stats.dig("other", "activity", "time"),
- other_activity_streak_current: stats.dig("other", "activity", "streak", "current"),
- other_activity_streak_best: stats.dig("other", "activity", "streak", "best"),
- other_awards: stats.dig("other", "awards"),
- other_merits_bought: stats.dig("other", "merits_bought"),
- other_refills_energy: stats.dig("other", "refills", "energy"),
- other_refills_nerve: stats.dig("other", "refills", "nerve"),
- other_refills_token: stats.dig("other", "refills", "token"),
- other_donator_days: stats.dig("other", "donator_days"),
- other_ranked_war_wins: stats.dig("other", "ranked_war_wins")
- )
+ result
end
end
end
diff --git a/app/models/torn_api/user/profile.rb b/app/models/torn_api/user/profile.rb
index 1f75b49..a439dda 100644
--- a/app/models/torn_api/user/profile.rb
+++ b/app/models/torn_api/user/profile.rb
@@ -1,16 +1,36 @@
module TornApi
module User
class Profile < Base
- ENDPOINT = "v2/user/basic".freeze
+ ProfileData = Data.define(
+ :id,
+ :name,
+ :level,
+ :image
+ )
+
+ def endpoint
+ "v2/user/profile"
+ end
def fetch
- response = get(ENDPOINT, striptags: false)
+ response = get(endpoint, { striptags: true })
if response["profile"].present?
- response["profile"]
+ parse_profile(response["profile"])
else
- raise InvalidKeyError, "Torn API authentication failed: #{response}"
+ raise ApiError, "No profile data returned: #{response}"
end
end
+
+ private
+
+ def parse_profile(data)
+ ProfileData.new(
+ id: data["id"],
+ name: data["name"],
+ level: data["level"],
+ image: data["image"]
+ )
+ end
end
end
end
diff --git a/app/models/torn_api/user/stocks.rb b/app/models/torn_api/user/stocks.rb
index 44e675a..3b0efe3 100644
--- a/app/models/torn_api/user/stocks.rb
+++ b/app/models/torn_api/user/stocks.rb
@@ -7,22 +7,22 @@ class Stocks < Base
ENDPOINT = "v2/user/stocks".freeze
def fetch
- response = get(ENDPOINT, striptags: false)
+ response = get(ENDPOINT, { striptags: false })
if response["stocks"].present?
parse_user_stocks(response["stocks"])
else
- raise InvalidKeyError, "Torn API authentication failed: #{response}"
+ raise ApiError, "No user stocks data returned: #{response}"
end
end
private
def parse_user_stocks(stock_data)
- stock_data.map do |stock_id, stock_details|
+ stock_data.map do |stock_details|
UserStock.new(
- stock_id: stock_id.to_i,
- total_shares: stock_details["total_shares"],
- dividend: parse_dividend_info(stock_details["dividend"]),
+ stock_id: stock_details["id"],
+ total_shares: stock_details["shares"],
+ dividend: parse_dividend_info(stock_details["bonus"]),
transactions: parse_transactions(stock_details["transactions"])
)
end
@@ -32,7 +32,7 @@ def parse_dividend_info(dividend_data)
return nil unless dividend_data
Dividend.new(
- ready: dividend_data["ready"],
+ ready: dividend_data["available"],
increment: dividend_data["increment"],
progress: dividend_data["progress"],
frequency: dividend_data["frequency"]
@@ -42,11 +42,11 @@ def parse_dividend_info(dividend_data)
def parse_transactions(transactions_data)
return [] unless transactions_data
- transactions_data.map do |_, transaction_details|
+ transactions_data.map do |transaction_details|
Transaction.new(
shares: transaction_details["shares"],
- bought_price: transaction_details["bought_price"],
- time_bought: Time.at(transaction_details["time_bought"])
+ bought_price: transaction_details["price"],
+ time_bought: Time.at(transaction_details["timestamp"])
)
end
end
diff --git a/app/models/torn_stats_api.rb b/app/models/torn_stats_api.rb
new file mode 100644
index 0000000..35a1bff
--- /dev/null
+++ b/app/models/torn_stats_api.rb
@@ -0,0 +1,69 @@
+require "net/http"
+require "json"
+
+module TornStatsApi
+ class ApiError < StandardError; end
+ class RateLimitError < ApiError; end
+ class InvalidKeyError < ApiError; end
+ class NotFoundError < ApiError; end
+
+ class Base
+ BASE_URL = "https://www.tornstats.com"
+ DEFAULT_READ_TIMEOUT = 15
+ DEFAULT_OPEN_TIMEOUT = 5
+
+ attr_reader :api_key
+
+ def initialize(api_key)
+ raise InvalidKeyError, "No TornStats API key provided" if api_key.blank?
+ @api_key = api_key
+ end
+
+ def get(path)
+ uri = URI("#{BASE_URL}/#{path}")
+
+ Rails.logger.info("TornStatsAPI request: #{uri.path.gsub(api_key, '[REDACTED]')}")
+
+ response = perform_request(uri)
+ body = parse_response(response)
+
+ Rails.logger.debug("TornStatsAPI success: #{uri.path.gsub(api_key, '[REDACTED]')}")
+
+ body
+ rescue Net::ReadTimeout, Net::OpenTimeout => e
+ Rails.logger.error("TornStatsAPI timeout: #{e.message}")
+ raise ApiError, "TornStats API request timed out"
+ rescue JSON::ParserError => e
+ Rails.logger.error("TornStatsAPI JSON parse error: #{e.message}")
+ raise ApiError, "Invalid JSON response from TornStats API"
+ rescue Net::HTTPError, SocketError => e
+ Rails.logger.error("TornStatsAPI network error: #{e.message}")
+ raise ApiError, "Network error contacting TornStats: #{e.message}"
+ end
+
+ private
+
+ def perform_request(uri)
+ Net::HTTP.start(
+ uri.host,
+ uri.port,
+ use_ssl: true,
+ read_timeout: DEFAULT_READ_TIMEOUT,
+ open_timeout: DEFAULT_OPEN_TIMEOUT
+ ) do |http|
+ req = Net::HTTP::Get.new(uri)
+ req["accept"] = "application/json"
+ http.request(req)
+ end
+ end
+
+ def parse_response(response)
+ unless response.code.to_i == 200
+ Rails.logger.error("HTTP #{response.code} from TornStats API: #{response.body[0..500]}")
+ raise ApiError, "TornStats API request failed (HTTP #{response.code})"
+ end
+
+ JSON.parse(response.body)
+ end
+ end
+end
diff --git a/app/models/torn_stats_api/spy_faction.rb b/app/models/torn_stats_api/spy_faction.rb
new file mode 100644
index 0000000..540b877
--- /dev/null
+++ b/app/models/torn_stats_api/spy_faction.rb
@@ -0,0 +1,67 @@
+module TornStatsApi
+ class SpyFaction < Base
+ SpyData = Data.define(
+ :torn_id,
+ :name,
+ :level,
+ :strength,
+ :defense,
+ :speed,
+ :dexterity,
+ :total,
+ :spied_at
+ )
+
+ attr_reader :faction_id
+
+ def initialize(api_key, faction_id:)
+ super(api_key)
+ @faction_id = faction_id
+ end
+
+ def fetch
+ response = get("api/v2/#{api_key}/spy/faction/#{faction_id}")
+
+ unless response["status"]
+ message = response["message"] || "Unknown error"
+ raise NotFoundError, "TornStats spy data not available: #{message}"
+ end
+
+ faction_data = response["faction"]
+ unless faction_data && faction_data["members"]
+ raise NotFoundError, "No faction member data in TornStats response"
+ end
+
+ parse_members(faction_data["members"])
+ end
+
+ private
+
+ def parse_members(members_hash)
+ spies = []
+
+ members_hash.each do |torn_id, member_data|
+ spy = member_data["spy"]
+
+ if spy && spy["total"]
+ spy_timestamp = spy["timestamp"]
+ spied_at = spy_timestamp ? Time.at(spy_timestamp.to_i) : nil
+
+ spies << SpyData.new(
+ torn_id: torn_id.to_i,
+ name: member_data["name"],
+ level: member_data["level"],
+ strength: spy["strength"]&.to_i,
+ defense: spy["defense"]&.to_i,
+ speed: spy["speed"]&.to_i,
+ dexterity: spy["dexterity"]&.to_i,
+ total: spy["total"]&.to_i,
+ spied_at: spied_at
+ )
+ end
+ end
+
+ spies
+ end
+ end
+end
diff --git a/app/models/torn_user.rb b/app/models/torn_user.rb
deleted file mode 100644
index c5c92f1..0000000
--- a/app/models/torn_user.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-class TornUser < ApplicationRecord
- has_one :user, dependent: :nullify
- has_many :personal_stat_snapshots, dependent: :destroy
- scope :hof_stats_users, -> { where(hof_stats_user: true) }
-end
diff --git a/app/models/user.rb b/app/models/user.rb
index 73d7442..d00de7f 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -1,4 +1,122 @@
class User < ApplicationRecord
+ belongs_to :faction, optional: true
has_many :sessions, dependent: :destroy
- belongs_to :torn_user, optional: true
+ has_many :personal_stat_snapshots, dependent: :destroy
+ has_many :received_xanax_payments, class_name: "XanaxPayment", foreign_key: :recipient_id, dependent: :destroy
+ has_many :sent_xanax_payments, class_name: "XanaxPayment", foreign_key: :sender_id
+ has_many :subscription_grants, dependent: :destroy
+ has_many :faction_subscription_grants, through: :subscription_grants
+ has_many :granted_faction_subscriptions, class_name: "FactionSubscriptionGrant", foreign_key: :granted_by_id
+ has_many :api_calls, dependent: :destroy
+ has_one :torn_api_key, class_name: "ApiKey::Torn", foreign_key: :user_id, dependent: :destroy
+ has_one :subscription, as: :subscribable, dependent: :destroy
+
+ validates :torn_id, presence: true, uniqueness: true
+ validates :name, presence: true
+ validates :level, presence: true
+
+ scope :hof_stats_users, -> { where(hof_stats_user: true) }
+ scope :active_subscribers, -> {
+ left_joins(:subscription).where("subscriptions.expires_at > ?", Time.current)
+ }
+ scope :active, -> { where(fallen: false) }
+ scope :fallen, -> { where(fallen: true) }
+ scope :tracked_for_stats, -> {
+ base = left_joins(faction: :api_keys).where(fallen: false)
+ base.where(hof_stats_user: true)
+ .or(base.where(factions: { setup_completed: true }, api_keys: { type: "ApiKey::Torn" }))
+ .distinct
+ }
+
+ LIMITED_ACCESS_TYPES = [ "Limited Access", "Full Access", "Custom" ].freeze
+
+ def self.find_by_api_key(key)
+ joins(:torn_api_key).find_by(api_keys: { key: key })
+ end
+
+ def subscribed?
+ (subscription&.expires_at.present? && subscription.expires_at > Time.current) ||
+ (faction&.subscription&.expires_at.present? && faction.subscription.expires_at > Time.current)
+ end
+
+ def personal_subscription_active?
+ subscription&.expires_at.present? && subscription.expires_at > Time.current
+ end
+
+ def subscription_weeks_remaining
+ return 0 unless personal_subscription_active?
+ ((subscription.expires_at - Time.current) / 1.week).round
+ end
+
+ def effective_subscription_expires_at
+ candidates = []
+ candidates << subscription.expires_at if subscription&.expires_at.present?
+ candidates << faction.subscription.expires_at if faction&.subscription&.expires_at.present?
+ candidates.compact.max
+ end
+
+ def extend_subscription!(weeks)
+ if subscription
+ subscription.extend!(weeks)
+ else
+ create_subscription!(expires_at: Time.current + weeks.weeks)
+ end
+ end
+
+ def deduct_subscription!(weeks)
+ raise "Not enough subscription time remaining" unless subscription_weeks_remaining >= weeks
+ subscription.update!(expires_at: subscription.expires_at - weeks.weeks)
+ end
+
+ ADMIN_TORN_ID = 2728237
+
+ def admin?
+ torn_id == ADMIN_TORN_ID
+ end
+
+ def hof_access?
+ admin? || torn_id == 2685512
+ end
+
+ HOF_STAT_ENHANCER_THRESHOLD = 200
+
+ def check_hof_eligibility!(stat_enhancer_count)
+ update!(hof_stats_user: true) if stat_enhancer_count.to_i > HOF_STAT_ENHANCER_THRESHOLD
+ end
+
+ def faction_leader?
+ %w[Leader Co-leader].include?(position)
+ end
+
+ def has_limited_access?
+ LIMITED_ACCESS_TYPES.include?(api_access_type)
+ end
+
+ def api_key
+ torn_api_key&.key
+ end
+
+ def api_access_type
+ torn_api_key&.access_type
+ end
+
+ def set_api_key!(key, access_type)
+ if key.nil?
+ torn_api_key&.destroy!
+ self.torn_api_key = nil
+ elsif torn_api_key
+ torn_api_key.update!(key: key, access_type: access_type)
+ else
+ create_torn_api_key!(key: key, access_type: access_type)
+ end
+ end
+
+ def backfill_in_progress?
+ backfill_ends_at.present? && backfill_ends_at > Time.current
+ end
+
+ def backfill_seconds_remaining
+ return 0 unless backfill_in_progress?
+ (backfill_ends_at - Time.current).to_i
+ end
end
diff --git a/app/models/user_stock.rb b/app/models/user_stock.rb
deleted file mode 100644
index 9714c1d..0000000
--- a/app/models/user_stock.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-class UserStock
- Transaction = Data.define(:shares, :bought_price, :time_bought)
- DividendInfo = Data.define(:ready, :increment, :progress, :frequency)
-
- attr_reader :stock, :total_shares, :transactions, :dividend_info
-
- def initialize(stock:, total_shares:, transactions: {}, dividend_info: nil)
- @stock = stock
- @total_shares = total_shares
- @transactions = parse_transactions(transactions)
- @dividend_info = parse_dividend_info(dividend_info)
- end
-
- def dividend_blocks
- base = stock.base_increment
- blocks = 0
- remaining = total_shares
-
- while remaining >= base
- blocks += 1
- remaining -= base
- base *= 2
- end
-
- blocks
- end
-
- def days_remaining_for_dividend
- return nil unless dividend_info
-
- dividend_info.frequency - dividend_info.progress
- end
-
- def dividend_ready?
- dividend_info && dividend_info["ready"] == 1
- end
-
- def summary
- {
- "Stock" => stock.name,
- "Torn ID" => stock.torn_id,
- "Total Shares" => total_shares,
- "Dividend Blocks" => dividend_blocks,
- "Dividend Ready?" => dividend_ready?,
- "Days Remaining for Dividend" => days_remaining_for_dividend
- }
- end
-
- private
-
- def parse_transactions(transactions_hash)
- transactions_hash.map do |_, details|
- Transaction.new(
- shares: details["shares"],
- bought_price: details["bought_price"],
- time_bought: Time.at(details["time_bought"])
- )
- end
- end
-
- def parse_dividend_info(dividend_info_hash)
- return nil unless dividend_info_hash
-
- DividendInfo.new(
- ready: dividend_info_hash["ready"],
- increment: dividend_info_hash["increment"],
- progress: dividend_info_hash["progress"],
- frequency: dividend_info_hash["frequency"]
- )
- end
-end
diff --git a/app/models/xanax_payment.rb b/app/models/xanax_payment.rb
new file mode 100644
index 0000000..444613e
--- /dev/null
+++ b/app/models/xanax_payment.rb
@@ -0,0 +1,11 @@
+class XanaxPayment < ApplicationRecord
+ belongs_to :recipient, class_name: "User"
+ belongs_to :sender, class_name: "User"
+
+ validates :log_id, presence: true, uniqueness: true
+ validates :xanax_amount, presence: true, numericality: { greater_than: 0 }
+ validates :weeks_granted, presence: true, numericality: { greater_than: 0 }
+ validates :processed_at, presence: true
+
+ scope :recent, -> { order(processed_at: :desc) }
+end
diff --git a/app/services/compliance_summary.rb b/app/services/compliance_summary.rb
new file mode 100644
index 0000000..47ef389
--- /dev/null
+++ b/app/services/compliance_summary.rb
@@ -0,0 +1,141 @@
+class ComplianceSummary
+ include FactionHelper
+
+ CACHE_TTL = 1.hour
+
+ attr_reader :faction, :start_date, :end_date, :member_rows,
+ :compliant_count, :warning_count, :non_compliant_count, :total_days
+
+ def initialize(faction, start_date: nil, end_date: nil)
+ @faction = faction
+ @start_date = start_date || PersonalStatSnapshot.tracking_start_date
+ @end_date = end_date || PersonalStatSnapshot.tracking_end_date
+ @total_days = (@end_date - @start_date).to_i + 1
+ @member_rows = []
+
+ load_cached_results
+ end
+
+ def worst_performers(limit = 5)
+ member_rows.sort_by { |row| row[:compliance_score] }.first(limit)
+ end
+
+ private
+
+ def load_cached_results
+ cached = Rails.cache.fetch(cache_key, expires_in: CACHE_TTL) { compute }
+
+ @member_rows = cached[:member_rows]
+ @compliant_count = cached[:compliant_count]
+ @warning_count = cached[:warning_count]
+ @non_compliant_count = cached[:non_compliant_count]
+ end
+
+ def cache_key
+ "compliance_summary:#{faction.id}:#{start_date}:#{end_date}:#{faction.updated_at.to_i}"
+ end
+
+ def compute
+ query_start_date = start_date - 1.day
+ active_users = faction.users.active.to_a
+
+ snapshots_by_user = PersonalStatSnapshot
+ .where(user_id: active_users.map(&:id))
+ .where(date: query_start_date..end_date)
+ .order(:date)
+ .group_by(&:user_id)
+
+ rows = active_users.filter_map do |user|
+ user_snapshots = snapshots_by_user[user.id] || []
+ build_member_row(user, user_snapshots)
+ end
+
+ {
+ member_rows: rows,
+ compliant_count: rows.count { |row| row[:compliance_level] == :compliant },
+ warning_count: rows.count { |row| row[:compliance_level] == :warning },
+ non_compliant_count: rows.count { |row| row[:compliance_level] == :danger }
+ }
+ end
+
+ def build_member_row(user, snapshots)
+ xanax_stats = calculate_stat(snapshots, :drugs_xanax)
+ energy_stats = calculate_stat(snapshots, :other_refills_energy)
+ nerve_stats = calculate_stat(snapshots, :other_refills_nerve)
+ missions_stats = calculate_stat(snapshots, :missions_contracts_total)
+ crimes_stats = calculate_stat(snapshots, :crimes_offenses_total)
+ activity_stats = calculate_stat(snapshots, :other_activity_time)
+ networth_stats = calculate_stat(snapshots, :networth_total)
+
+ return if xanax_stats[:days].zero? && energy_stats[:days].zero? && nerve_stats[:days].zero?
+
+ days_tracked = [
+ xanax_stats[:days], energy_stats[:days], nerve_stats[:days],
+ missions_stats[:days], crimes_stats[:days], activity_stats[:days],
+ networth_stats[:days]
+ ].max
+
+ xanax_daily = xanax_stats[:daily]
+ energy_refills_daily = energy_stats[:daily]
+ nerve_refills_daily = nerve_stats[:daily]
+ missions_daily = missions_stats[:daily]
+ crimes_daily = crimes_stats[:daily]
+ activity_time_daily = activity_stats[:days] > 0 ? (activity_stats[:gained].to_f / 60 / activity_stats[:days]).round(0) : 0
+
+ ssl_user = user.ssl_user?
+ xanax_compliance = ssl_user ? :green : stat_compliance(xanax_daily, faction.xanax_target)
+ energy_compliance = stat_compliance(energy_refills_daily, faction.energy_refill_target)
+ nerve_compliance = stat_compliance(nerve_refills_daily, faction.nerve_refill_target)
+
+ compliance_level = member_compliance_level(xanax_compliance, energy_compliance, nerve_compliance)
+ score = ssl_user ? compliance_score_ssl(energy_refills_daily, nerve_refills_daily, faction) : compliance_score(xanax_daily, energy_refills_daily, nerve_refills_daily, faction)
+
+ {
+ torn_id: user.torn_id,
+ name: user.name,
+ ssl_user: ssl_user,
+ compliance_level: compliance_level,
+ compliance_score: score,
+
+ xanax_gained: xanax_stats[:gained],
+ xanax_daily: xanax_daily,
+ xanax_compliance: xanax_compliance,
+
+ energy_refills_gained: energy_stats[:gained],
+ energy_refills_daily: energy_refills_daily,
+ energy_refills_compliance: energy_compliance,
+
+ nerve_refills_gained: nerve_stats[:gained],
+ nerve_refills_daily: nerve_refills_daily,
+ nerve_refills_compliance: nerve_compliance,
+
+ missions_gained: missions_stats[:gained],
+ missions_daily: missions_daily,
+
+ crimes_gained: crimes_stats[:gained],
+ crimes_daily: crimes_daily,
+
+ activity_time_gained: activity_stats[:gained],
+ activity_time_daily: activity_time_daily,
+
+ networth_gained: networth_stats[:gained],
+ networth_current: networth_stats[:current],
+
+ days_tracked: days_tracked
+ }
+ end
+
+ def calculate_stat(snapshots, field)
+ relevant = snapshots.select { |s| s[field].present? }
+ return { gained: 0, daily: 0.0, days: 0, current: 0 } if relevant.size < 2
+
+ first = relevant.first
+ last = relevant.last
+ gained = (last[field] || 0) - (first[field] || 0)
+
+ actual_days = (last.date - first.date).to_i
+ daily = actual_days > 0 ? (gained.to_f / actual_days).round(2) : 0.0
+
+ { gained: gained, daily: daily, days: actual_days, current: last[field] || 0 }
+ end
+end
diff --git a/app/views/admin/api_logs/index.html.erb b/app/views/admin/api_logs/index.html.erb
new file mode 100644
index 0000000..b274ba6
--- /dev/null
+++ b/app/views/admin/api_logs/index.html.erb
@@ -0,0 +1,102 @@
+
+
+
+
+
Total Calls
+
<%= number_with_delimiter(@total_calls) %>
+
+
+
+
Calls Today
+
<%= number_with_delimiter(@calls_today) %>
+
+
+
+
Last 24 Hours
+
<%= number_with_delimiter(@calls_last_24h) %>
+
+
+
+
Success Rate
+
+ <%= @total_calls > 0 ? "#{((@successful_calls.to_f / @total_calls) * 100).round(1)}%" : "N/A" %>
+
+
+
+
+
Avg Response Time
+
<%= @avg_response_time ? "#{@avg_response_time}ms" : "N/A" %>
+
+
+
+
Failed Calls
+
<%= number_with_delimiter(@failed_calls) %>
+
+
+
+
Peak Rate Today
+
+ <%= @peak_rate_today[:rate] %>/min
+
+ <% if @peak_rate_today[:minute_start].present? %>
+
at <%= @peak_rate_today[:minute_start] %>
+ <% end %>
+
+
+
Recent API Calls (Last 500)
+
+ <% if @api_logs.any? %>
+
+
+
+ TIMESTAMP
+ ENDPOINT
+ SELECTIONS
+ STATUS
+ RESPONSE TIME
+ ERROR
+
+
+
+ <% @api_logs.each do |log| %>
+ <% selections = log.selections.present? ? JSON.parse(log.selections) : {} %>
+
+ <%= log.created_at.strftime("%d-%m-%Y %H:%M:%S") %>
+ <%= log.endpoint %>
+ <% if selections.any? %>
+ <% selections.each do |key, value| %>
+
+ <%= key %>:
+ <% if key == "timestamp" && value.is_a?(Integer) %>
+ <%= Time.at(value).utc.strftime("%d-%m-%Y") %>
+ <% else %>
+ <%= value.to_s %>
+ <% end %>
+
+ <% end %>
+ <% else %>
+ -
+ <% end %>
+
+
+
+ <%= log.status.upcase %>
+
+
+ <%= log.response_time ? "#{log.response_time}ms" : "N/A" %>
+ <%= log.error_message&.truncate(50) || "-" %>
+
+ <% end %>
+
+
+ <% else %>
+
No API logs found for the admin API key.
+ <% end %>
+
+
+ <%= link_to faction.name, "https://www.torn.com/factions.php?step=profile&ID=#{faction.torn_id}", target: "_blank" %>
+
+ <%= faction.torn_id %>
+
+ <%= faction.users.active.count %><% if faction.users.fallen.any? %> (+<%= faction.users.fallen.count %> fallen) <% end %>
+ <% if faction.users.any? %>
+ View
+ <% end %>
+
+
+
+ Xanax: <%= faction.xanax_target %>/day
+
+
+
+
+
+
+ <%= link_to "Edit Targets", edit_admin_faction_path(faction), class: "btn-small" %>
+ <%= button_to "Backfill Armory", backfill_armory_news_admin_faction_path(faction), method: :post, class: "btn-small" %>
+ <%= button_to "Delete", admin_faction_path(faction), method: :delete, class: "btn-small btn-small-danger", data: { turbo_confirm: "Are you sure you want to remove '#{faction.name}'?" } %>
+
+
+
+<% if faction.users.any? %>
+
+
+
+
Active Members (<%= faction.users.active.count %>)
+
+ <% faction.users.active.order(:name).each do |user| %>
+
+
+ <%= link_to user.name, "https://www.torn.com/profiles.php?XID=#{user.torn_id}", target: "_blank", style: "color:#e5e5e5; text-decoration:none;" %>
+ [<%= user.torn_id %>]
+ <% if user.ssl_user? %>
+ SSL
+ <% end %>
+
+
+
+ SSL
+
+
+
+ <% end %>
+
+ <% if faction.users.fallen.any? %>
+
Fallen Members (<%= faction.users.fallen.count %>)
+
+ <% faction.users.fallen.order(:name).each do |user| %>
+
+
+ <%= link_to user.name, "https://www.torn.com/profiles.php?XID=#{user.torn_id}", target: "_blank", style: "color:#737373; text-decoration:none;" %>
+ [<%= user.torn_id %>]
+
+
+ <% end %>
+
+ <% end %>
+
+
+<% end %>
+
+
diff --git a/app/views/admin/factions/_form.html.erb b/app/views/admin/factions/_form.html.erb
new file mode 100644
index 0000000..101effe
--- /dev/null
+++ b/app/views/admin/factions/_form.html.erb
@@ -0,0 +1,14 @@
+<%= form_with url: admin_factions_path, class: "inline-add-form", data: { turbo_frame: "add_faction" } do |form| %>
+ <% if @error.present? %>
+ <%= @error %>
+ <% end %>
+
+
+ <%= form.number_field :torn_id,
+ placeholder: "Faction ID (e.g. 9055)",
+ class: "form-input",
+ required: true,
+ min: 1 %>
+ <%= form.submit "Add Faction", class: "btn-primary" %>
+
+<% end %>
diff --git a/app/views/admin/factions/create.turbo_stream.erb b/app/views/admin/factions/create.turbo_stream.erb
new file mode 100644
index 0000000..f703247
--- /dev/null
+++ b/app/views/admin/factions/create.turbo_stream.erb
@@ -0,0 +1,4 @@
+<%= turbo_stream.append "factions", @faction %>
+<%= turbo_stream.replace "add_faction" do %>
+ <%= render "form" %>
+<% end %>
diff --git a/app/views/admin/factions/edit.html.erb b/app/views/admin/factions/edit.html.erb
new file mode 100644
index 0000000..730d9e2
--- /dev/null
+++ b/app/views/admin/factions/edit.html.erb
@@ -0,0 +1,47 @@
+
+
+
+
+
+ <%= form_with model: @faction, url: admin_faction_path(@faction), method: :patch do |form| %>
+ <% if @faction.errors.any? %>
+
+
<%= pluralize(@faction.errors.count, "error") %> prevented this faction from being saved:
+
+ <% @faction.errors.full_messages.each do |message| %>
+ <%= message %>
+ <% end %>
+
+
+ <% end %>
+
+
+ <%= form.label :xanax_target, "Xanax (per day)" %>
+ <%= form.number_field :xanax_target, step: 0.1, min: 0.1, class: "form-input" %>
+ Minimum xanax consumption expected per member per day
+
+
+
+ <%= form.label :energy_refill_target, "Energy Refills (per day)" %>
+ <%= form.number_field :energy_refill_target, step: 0.1, min: 0, class: "form-input" %>
+ Minimum energy refills expected per member per day. Set to 0 to disable.
+
+
+
+ <%= form.label :nerve_refill_target, "Nerve Refills (per day)" %>
+ <%= form.number_field :nerve_refill_target, step: 0.1, min: 0, class: "form-input" %>
+ Minimum nerve refills expected per member per day. Set to 0 to disable.
+
+
+
+ <%= form.submit "Update Targets", class: "btn-primary" %>
+ <%= link_to "Cancel", admin_factions_path, class: "btn-secondary" %>
+
+ <% end %>
+
+
+
+ <%= turbo_frame_tag "add_faction" do %>
+ <%= render "form" %>
+ <% end %>
+
+
+
+
+
+ Name
+ Torn ID
+ Members
+ Daily Targets
+ Public Wars
+ Actions
+
+
+
+ <%= render @factions %>
+
+
+
+
+ <% if @factions.empty? %>
+
+
No factions added yet. Use the form above to start tracking a faction's members.
+
+ <% end %>
+
+ <%= turbo_frame_tag "add_faction" do %>
+ <%= render "form" %>
+ <% end %>
+
+ <%= link_to "Back to Factions", admin_factions_path, class: "btn-secondary mt-4" %>
+
diff --git a/app/views/admin/recon/_feature_card.html.erb b/app/views/admin/recon/_feature_card.html.erb
new file mode 100644
index 0000000..dec46e9
--- /dev/null
+++ b/app/views/admin/recon/_feature_card.html.erb
@@ -0,0 +1,39 @@
+
+
+
+
+ <% max_bin = d[:histogram].max || 1 %>
+ <% d[:histogram].each_with_index do |count, i| %>
+ <% height_pct = max_bin > 0 ? (count * 100.0 / max_bin).round(1) : 0 %>
+
+ <% end %>
+
+
+
+
+ Mean <%= number_with_delimiter(d[:mean].round) %>
+
+
+ Median <%= number_with_delimiter(d[:median].round) %>
+
+
+ Std <%= number_with_delimiter(d[:std].round) %>
+
+
+ Range <%= number_with_delimiter(d[:min]) %> - <%= number_with_delimiter(d[:max]) %>
+
+
+ P25 / P75 <%= number_with_delimiter(d[:p25]) %> / <%= number_with_delimiter(d[:p75]) %>
+
+
+ N <%= d[:count] %>
+
+
+
+ <% if local_assigns[:error] && error.present? %>
+
<%= error %>
+ <% elsif local_assigns[:prediction] %>
+
+
+
Estimated Total Battle Stats
+
<%= number_with_delimiter(prediction) %>
+
+
+
+
+ Feature values used
+
+ <% features.sort_by { |k, _| Recon::TrainingSample::FEATURE_COLUMNS.index(k) || 99 }.each do |key, value| %>
+
+ <%= key %>
+ <%= number_with_delimiter(value) %>
+
+ <% end %>
+
+
+ <% end %>
+
+
+
Training Samples
+
<%= number_with_delimiter(@training_sample_count) %>
+
+
+
Latest Sample
+
<%= @latest_sample&.created_at&.strftime("%d %b %Y %H:%M") || "None" %>
+
+
+
Predict Battle Stats
+
Enter a Torn player ID to estimate their total battle stats using the trained model.
+
+ <%= form_with url: predict_admin_recon_path, method: :post, class: "predict-form", data: { turbo_stream: true } do |form| %>
+
+ <%= form.text_field :torn_id, placeholder: "Torn ID", class: "predict-input", autofocus: true, inputmode: "numeric" %>
+ <%= form.submit "Predict", class: "btn btn-primary" %>
+
+ <% end %>
+
+
+
+
Quick Add Sample
+
Manually add a training sample. Personalstats will be fetched automatically from the API.
+
+ <%= form_with url: quick_add_admin_recon_path, method: :post, class: "predict-form" do |form| %>
+
+ <%= form.text_field :torn_id, placeholder: "Torn ID", class: "predict-input", inputmode: "numeric" %>
+ <%= form.text_field :strength, placeholder: "STR", class: "predict-input" %>
+ <%= form.text_field :defense, placeholder: "DEF", class: "predict-input" %>
+ <%= form.text_field :speed, placeholder: "SPD", class: "predict-input" %>
+ <%= form.text_field :dexterity, placeholder: "DEX", class: "predict-input" %>
+ <%= form.submit "Add Sample", class: "btn btn-primary" %>
+
+ <% end %>
+
+
+
+
+ Collecting training samples
+ Fetching personalstats and profile data from the Torn API for each imported spy.
+ Estimated time remaining:
+
+
+
+
Import Spy Data
+
Paste tab-separated spy data from TornStats, YATA, or any spy tool. Each row will be paired with historical personalstats from the Torn API to create training samples.
+
+ <%= form_with url: import_admin_recon_path, method: :post, class: "recon-import-form" do |form| %>
+ <%= form.text_area :spy_data,
+ class: "recon-import-textarea",
+ placeholder: "Paste TornStats data here!\n\nFaction spy format:\nName [ID] Level Faction STR DEF SPD DEX Total FF Date\n\nFaction member format:\nRank Name [ID] Level STR DEF SPD DEX Total Date LastAction Score",
+ rows: 12 %>
+
+
+ <%= form.submit "Import & Queue Jobs", class: "btn btn-primary" %>
+
Each row requires 3 Torn API calls (2 personalstats batches + 1 profile). Existing samples will be updated.
+
+ <% end %>
+
+
Upload JSONL File
+
Upload a JSONL file with spy data. Each line should be a JSON object with Name (including [ID]), Strength, Defense, Speed, Dexterity, and Last Update fields.
+
+ <%= form_with url: import_file_admin_recon_path, method: :post, multipart: true, class: "recon-import-form" do |form| %>
+
+ <%= form.file_field :file, accept: ".jsonl,.json", class: "form-input" %>
+ <%= form.submit "Upload & Queue Jobs", class: "btn btn-primary" %>
+
+ <% end %>
+
+
Training Samples (<%= number_with_delimiter(@training_sample_count) %>)
+
+ <% if @samples.any? %>
+
+
+
+
+ Player
+ STR
+ DEF
+ SPD
+ DEX
+ Total
+ Spied At
+ Collected
+
+
+ <% @samples.each do |sample| %>
+
+
+
+
+ <%= sample.player_id %>
+
+
+ <%= number_with_delimiter(sample.strength) %>
+ <%= number_with_delimiter(sample.defense) %>
+ <%= number_with_delimiter(sample.speed) %>
+ <%= number_with_delimiter(sample.dexterity) %>
+ <%= number_with_delimiter(sample.total_stats) %> <%= sample.spied_at.strftime("%d %b %Y") %>
+ <%= sample.created_at.strftime("%d %b %H:%M") %>
+
+
+
+
+ <% sample.features.each do |key, value| %>
+
+ <%= key %>
+ <%= value.present? ? number_with_delimiter(value) : "—" %>
+
+ <% end %>
+
+
+
+ <% end %>
+
+
+ <% else %>
+
+
No training samples yet. Import spy data above to get started.
+
+ <% end %>
+
+
No complete training samples yet.
+
+ Total samples: <%= number_with_delimiter(@complete_samples) %>Incomplete: <%= @incomplete_samples %>After clipping: <%= number_with_delimiter(@sample_count) %> (<%= @clipped_count %> removed)Features: <%= Recon::TrainingSample::FEATURE_COLUMNS.size %>
+
+
+ <%= form_tag stats_admin_recon_path, method: :get, class: "recon-filter-form" do %>
+ Clip outliers (top/bottom %)
+ <%= number_field_tag :clip, @clip_pct, min: 0, max: 10, step: 0.5, class: "recon-filter-input" %>
+ <%= submit_tag "Apply", class: "btn btn-sm btn-primary" %>
+ <% end %>
+
+
+ <% if @total_stats_dist %>
+ Total Battle Stats Distribution
+
+ <% max_bin = @total_stats_dist[:histogram].max || 1 %>
+
+ <% @total_stats_dist[:histogram].each_with_index do |count, i| %>
+ <% height_pct = max_bin > 0 ? (count * 100.0 / max_bin).round(1) : 0 %>
+
+ <% end %>
+
+ " />
+
+
+
+ Mean: <%= number_with_delimiter(@total_stats_dist[:mean].round) %>
+ Median: <%= number_with_delimiter(@total_stats_dist[:median].round) %>
+ Std: <%= number_with_delimiter(@total_stats_dist[:std].round) %>
+ Range: <%= number_with_delimiter(@total_stats_dist[:min]) %> - <%= number_with_delimiter(@total_stats_dist[:max]) %>
+ N: <%= number_with_delimiter(@total_stats_dist[:count]) %>
+
+
+
Data Quality Warnings (<%= @warnings.size %>)
+
+ <% @warnings.each do |w| %>
+
+ <%= w[:feature] %> - <%= w[:message] %>
+
+ <% end %>
+
+
Labels (Battle Stats)
+
+ <% Recon::TrainingSample::LABEL_COLUMNS.each do |col| %>
+ <% next unless @distributions[col] %>
+ <%= render partial: "admin/recon/feature_card", locals: { col: col, d: @distributions[col] } %>
+ <% end %>
+
+
+ Features
+
+ <% Recon::TrainingSample::FEATURE_COLUMNS.each do |col| %>
+ <% next unless @distributions[col] %>
+ <%= render partial: "admin/recon/feature_card", locals: { col: col, d: @distributions[col] } %>
+ <% end %>
+
+<% end %>
diff --git a/app/views/admin/script_versions/edit.html.erb b/app/views/admin/script_versions/edit.html.erb
new file mode 100644
index 0000000..4266903
--- /dev/null
+++ b/app/views/admin/script_versions/edit.html.erb
@@ -0,0 +1,40 @@
+
+
+
+ <%= form_with model: @script_version, url: admin_script_version_path(@script_version), method: :patch do |form| %>
+ <% if @script_version.errors.any? %>
+
+ <%= @script_version.errors.full_messages.to_sentence %>
+
+ <% end %>
+
+
+ <%= form.label :version %>
+ <%= form.text_field :version, class: "form-input" %>
+
+
+
+ <%= form.label :changelog %>
+ <%= form.text_field :changelog, class: "form-input" %>
+
+
+
+ <%= form.label :released_at, "Release date" %>
+ <%= form.date_field :released_at, class: "form-input" %>
+
+
+
+ <%= form.label :script_file, "Replace script file (.user.js)" %>
+ <%= form.file_field :script_file, accept: ".js", class: "form-input" %>
+ Leave blank to keep the current file.
+
+
+
+ <%= form.submit "Update Version", class: "btn-primary" %>
+ <%= link_to "Cancel", admin_script_versions_path, class: "btn-secondary" %>
+
+ <% end %>
+
+
+
+ <%= form_with model: @script_version, url: admin_script_versions_path do |form| %>
+ <% if @script_version.errors.any? %>
+
+ <%= @script_version.errors.full_messages.to_sentence %>
+
+ <% end %>
+
+
+ <% end %>
+
+
+
+
+
+
+
+ Version
+ Released
+ Changes
+
+
+
+ <% @script_versions.each do |version| %>
+
+ <%= version.version %>
+ <%= version.released_at.strftime("%-d %B %Y") %>
+ <%= version.changelog %>
+
+ <%= link_to "Edit", edit_admin_script_version_path(version), class: "btn-small" %>
+ <%= button_to "Delete", admin_script_version_path(version), method: :delete, class: "btn-small-danger", data: { turbo_confirm: "Delete version #{version.version}?" } %>
+
+
+ <% end %>
+
+
+
+
+
+
+
+ User
+ Faction
+ Missing
+ Oldest Gap
+ Latest Snapshot
+ Actions
+
+
+ <% users_with_gaps.each do |data| %>
+
+
+
+
+ <%= data[:user].name %>
+
+ [<%= data[:user].torn_id %>]
+
+
+ <% if data[:user].faction %>
+ <%= data[:user].faction.name %>
+ <% else %>
+ HoF
+ <% end %>
+
+
+
+ <%= data[:missing_count] %> days
+
+
+ <%= data[:oldest_missing]&.strftime("%d-%m-%Y") || "-" %>
+ <%= data[:latest_snapshot]&.strftime("%d-%m-%Y") || "Never" %>
+
+ <%= button_to "Backfill",
+ backfill_user_admin_snapshot_management_path(data[:user]),
+ method: :post,
+ class: "btn-small btn-primary",
+ data: { action: "click->backfill-row#remove" } %>
+
+
+ Details
+
+
+
+
+
+
+
Missing dates:
+
+ <% data[:missing_dates].first(30).each do |date| %>
+ <%= date.strftime("%d-%m-%Y") %>
+ <% end %>
+ <% if data[:missing_dates].size > 30 %>
+ ... and <%= data[:missing_dates].size - 30 %> more
+ <% end %>
+
+
+
+
+ <% end %>
+
+
<%= flash[:notice] %>
+<% end %>
+
+
+
Coverage Summary
+
+
+
<%= @summary[:tracked_users] %>
+
Tracked Users
+
+
+
<%= number_with_delimiter(@summary[:total_expected]) %>
+
Expected Snapshots
+
+
+
<%= number_with_delimiter(@summary[:total_existing]) %>
+
Existing Snapshots
+
+
+
<%= number_with_delimiter(@summary[:total_missing]) %>
+
Missing Snapshots
+
+
+
<%= @summary[:coverage_percent] %>%
+
Coverage Rate
+
+
+
+
Faction Members With Missing Snapshots (<%= @faction_users_with_gaps.size %>)
+ <% if @faction_users_with_gaps.any? %>
+ <%= render partial: "admin/snapshot_management/gap_table", locals: { users_with_gaps: @faction_users_with_gaps } %>
+ <% else %>
+
All faction members have complete snapshot coverage!
+ <% end %>
+
+
HoF Users With Missing Snapshots (<%= @hof_users_with_gaps.size %>)
+ <% if @hof_users_with_gaps.any? %>
+ <%= render partial: "admin/snapshot_management/gap_table", locals: { users_with_gaps: @hof_users_with_gaps } %>
+ <% else %>
+
All HoF users have complete snapshot coverage!
+ <% end %>
+
+
+
+ <%# ── 1. Health strip: do I need to act? ── %>
+
+ <% if @users_missing_yesterday > 0 %>
+ Collection <%= @users_missing_yesterday %> users missing yesterday's snapshot Collection all tracked users snapshotted yesterday Budget <%= @keys_over_budget %> keys peaked over <%= @per_key_budget %>/min (24h) Budget all keys ≤<%= @per_key_budget %>/min (24h) Queue <%= number_with_delimiter(@pipeline_stats[:failed]) %> failed jobs awaiting triage <% end %>
+ <% else %>
+ Queue no failed jobs Aggregate API <%= @api_peak_rate_today %>/min peak today · global cap <%= @global_budget %> Aggregate API <%= @api_peak_rate_today %>/min peak today · global cap <%= @global_budget %> Completeness <%= @completeness_pct %>% of <%= number_with_delimiter(@total_snapshots) %> snapshots
+
+ <%# ── 2. KPI hero row ── %>
+
+
+
<%= @tracked_users %>
+
Tracked users
+
of <%= number_with_delimiter(@total_users) %> total
+
+
+
<%= @total_subscribers %>
+
Active subs
+
<%= @xanax_received_past_month %> xanax (30d)
+
+
+
<%= number_with_delimiter(@api_calls_today) %>
+
API calls today
+
<%= number_with_delimiter(@api_calls_this_week) %> this week
+
+
+
<%= @api_peak_rate_today %>/min
+
Peak today
+
global budget <%= @global_budget %>/min
+
+
+
<%= @users_missing_yesterday %>
+
Missing yesterday
+
of <%= @tracked_users %> tracked (03:00 TCT)
+
+
+
<%= number_with_delimiter(@snapshots_this_week) %>
+
Snapshots this week
+
today: <%= @snapshots_today %>
+
+
+
+ <%# ── 3. Data collection ── %>
+
+
Data Collection snapshots · gaps · the nightly pipeline's output
+
+
+
+
Snapshot coverage
+
+
+ Total
+ <%= number_with_delimiter(@total_snapshots) %>
+
+
+ Days with data
+ <%= @unique_snapshot_days %>
+
+
+ Range
+ <%= @earliest_snapshot ? Time.at(@earliest_snapshot).utc.strftime("%d %b %Y") : "N/A" %> – <%= @latest_snapshot ? Time.at(@latest_snapshot).utc.strftime("%d %b %Y") : "N/A" %>
+
+
+ Complete / incomplete
+ <%= number_with_delimiter(@complete_snapshots) %> / <%= number_with_delimiter(@incomplete_snapshots) %>
+ <% if @tombstoned_snapshots > 0 %>
+
+ No data at Torn (tombstoned)
+ <%= number_with_delimiter(@tombstoned_snapshots) %>
+
+ <% end %>
+
+ <% if @daily_snapshots.any? %>
+ <% max_daily = [ @daily_snapshots.map(&:last).max, 1 ].max %>
+
+
Snapshots per day — last <%= @daily_snapshots.size %>
+
+ <% @daily_snapshots.each do |_date, count| %>
+
+ <% end %>
+
+
+ <% @daily_snapshots.each do |date, _count| %>
+ <%= Date.parse(date.to_s).strftime("%d") %>
+ <% end %>
+
+
+ <% end %>
+
+
+
+
Gaps — what backfill chases tonight
+
+
+ Users with gaps
+ <%= @users_with_gaps %>
+
+
+ Total missing days
+ <%= number_with_delimiter(@total_missing_snapshot_days) %>
+
+
+ Missing yesterday (03:00 TCT)
+ <%= @users_missing_yesterday %>
+
+
+ <% if @missing_dates_summary.any? %>
+
+ <% end %>
+
+
+
+
Pipeline health
+ <% if @pipeline_stats %>
+
+
+ Failed jobs
+ <%= link_to number_with_delimiter(@pipeline_stats[:failed]), "/jobs", class: "admin-plain-link", data: { turbo_prefetch: false, turbo: false } %>
+
+
+ Blocked (semaphores)
+ <%= number_with_delimiter(@pipeline_stats[:blocked]) %>
+
+
+ Scheduled retries
+ <%= number_with_delimiter(@pipeline_stats[:scheduled]) %>
+
+
+ Latest snapshot written
+ <%= @latest_snapshot ? Time.at(@latest_snapshot).utc.strftime("%d %b %H:%M") : "N/A" %>
+
+
+ Latest armoury entry
+ <%= @armory_latest&.strftime("%d %b %H:%M") || "N/A" %>
+
+
+
+ <% else %>
+
+ <% end %>
+
+
+
+
+ <%# ── 4. Torn API ── %>
+
+
Torn API 30d retention · budget: <%= @per_key_budget %>/min per key · <%= @global_budget %>/min global
+
+
+
+
Aggregate
+
+
+ Total calls
+ <%= number_with_delimiter(@total_api_calls) %>
+
+
+ Peak rate
+ <%= @api_peak_rate_all_time %>/min
+
+
+ Peak today
+ <%= @api_peak_rate_today %>/min
+
+
+
+
+ Admin key calls
+ <%= number_with_delimiter(@admin_api_total) %>
+
+
+ Admin peak rate
+ <%= @admin_api_peak_all_time %>/min
+
+
+ Admin peak today
+ <%= @admin_api_peak_today %>/min
+
+
+
+
+
+
Per key — last 24h · single-call keys folded
+ <% if @api_key_breakdown.any? %>
+
+
+ <% end %>
+
+
+
+
+ <%# ── 5. Factions ── %>
+
+
Factions <%= @total_factions %> total · <%= @active_factions %> active · sorted by status, then members
+
+ <% if @faction_rows.any? %>
+
+
+ <% end %>
+
+
+ <%# ── 6. Storage & volume ── %>
+
+
Storage & Volume big tables, slow growth
+
+
+
+
Member activity · kept forever
+
+
+ Snapshots
+ <%= number_with_delimiter(@activity_total_snapshots) %>
+
+
+ Growth
+ ~<%= number_with_delimiter(@activity_daily_growth) %>/day
+
+
+ Polls / members
+ <%= number_with_delimiter(@activity_total_polls) %> / <%= @activity_members_tracked %>
+
+
+ Range
+ <%= @activity_earliest&.strftime("%d %b %Y") || "N/A" %> – <%= @activity_latest&.strftime("%d %b %Y") || "N/A" %>
+
+
+
+
+
+
Armoury news · 365d retention
+
+
+ Entries
+ <%= number_with_delimiter(@armory_total_entries) %>
+
+
+ Range
+ <%= @armory_earliest&.strftime("%d %b %Y") || "N/A" %> – <%= @armory_latest&.strftime("%d %b %Y") || "N/A" %>
+
+
+ <% if @armory_by_faction.any? %>
+
+ <% end %>
+
+
+
+
Users & sessions
+
+
+ HoF users
+ <%= @hof_stats_users %>
+
+
+ API keys
+ <%= @api_keys_configured %>
+
+
+ Sessions this week
+ <%= @sign_ins_this_week %> · <%= @unique_sign_ins_this_week %> unique
+
+
+ <% if @subscribed_factions.any? %>
+
+ <% @subscribed_factions.each do |f| %>
+
+ <%= f.name %>
+ <%= f.subscription.days_remaining %>d left
+
+ <% end %>
+
+ <% end %>
+ <% if @new_sign_ins.any? %>
+
+
+ New User Joined
+
+ <% @new_sign_ins.each do |user| %>
+
+ <%= user.name %> <%= @first_session_dates[user.id]&.strftime("%d %b") || "—".html_safe %>
+
+ <% end %>
+
+
+ <% end %>
+
+
+
+
+ <%= form_with url: grant_admin_subscriptions_path, method: :post, class: "admin-sub-grant-form" do |form| %>
+ <%= form.select :target_type, [["User", "User"], ["Faction", "Faction"]], {}, class: "admin-sub-input admin-sub-input-sm" %>
+ <%= form.number_field :torn_id, required: true, min: 1, class: "admin-sub-input", placeholder: "Torn ID", inputmode: "numeric" %>
+ <%= form.number_field :weeks, required: true, min: 1, value: 1, class: "admin-sub-input admin-sub-input-sm", placeholder: "Wks", inputmode: "numeric" %>
+ <%= form.submit "Grant", class: "btn btn-sm btn-primary" %>
+ <% end %>
+
+
+
+
+
Factions (<%= @faction_subscriptions.count %>)
+ <% if @faction_subscriptions.any? %>
+
+ <% else %>
+
No faction subscriptions.
+ <% end %>
+
+
+
+
Individuals (<%= @individual_subscriptions.count %>)
+ <% if @individual_subscriptions.any? %>
+
+ <% else %>
+
No individual subscriptions.
+ <% end %>
+
+
+ Recent Payments (<%= @recent_payments.size %>)
+
+
+ Sender Xanax Weeks Date
+
+ <% @recent_payments.each do |payment| %>
+
+ <%= payment.sender.name %> <%= payment.xanax_amount %>
+ <%= payment.weeks_granted %>
+ <%= payment.processed_at.strftime("%d %b %H:%M") %>
+
+ <% end %>
+
+
+
+<% end %>
+
+
+
How it works: Users send Xanax to Bram [2728237]. Each Xanax grants 2 weeks of personal subscription. From the leadership dashboard, leaders can transfer their personal weeks to extend the faction subscription.
+
+
+
+
+
+
+
+
+
+
+
<%= @member_count %>
+
Members
+
+
+
+
+
+
+
+
+ <%= @war_wins %> W
+ /
+ <%= @war_losses %> L
+
+
War Record <%= Date.current.year %>
+
+
+
+
+
+
+
+
+ <% if @faction.backfill_in_progress? %>
+ --
+ /
+ --
+ /
+ --
+ <% else %>
+ <%= @compliant_members_count %>
+ /
+ <%= @warning_members_count %>
+ /
+ <%= @non_compliant_members_count %>
+ <% end %>
+
+
Compliance
+
+
+
+
+
+
+
+
<%= @xanax_target %>
+
Xanax Target/day
+
+
+
+
+
+
+
diff --git a/app/views/factions/_training_section.html.erb b/app/views/factions/_training_section.html.erb
new file mode 100644
index 0000000..882620c
--- /dev/null
+++ b/app/views/factions/_training_section.html.erb
@@ -0,0 +1,235 @@
+
+
+ <% backfill_in_progress = @faction.backfill_in_progress? %>
+ <% energy_enabled = @energy_target > 0 %>
+ <% nerve_enabled = @nerve_target > 0 %>
+ <%
+ def sortable_header(sort_info, faction)
+ chevron = '
+
+
+
+ <% if backfill_in_progress %>
+
+
+
+
+ Fetching historical data
+ Backfilling member stats up until <%= @faction.backfill_target_date&.strftime("%d %B %Y") %>.
+ Table will be enabled in:
+
+
+
+
+
+
+ <% if @backfilling_members.size == 1 %>
+ 1 member (<%= @backfilling_members.first.name %>) is being backfilled and will appear once data is available.
+ <% else %>
+ <%= @backfilling_members.size %> new members (<%= @backfilling_members.map(&:name).join(", ") %>) are being backfilled and will appear once data is available.
+ <% end %>
+
+
+
+
+
Data coverage at <%= @data_coverage_rate %>% — <%= number_with_delimiter(@data_total_missing_days) %> missing day<%= @data_total_missing_days == 1 ? "" : "s" %> may affect accuracy
+
+
+ <%= form_with url: faction_path(@faction), method: :get, class: "table-filter-form" do |form| %>
+
+
Tracking Period:
+
+
+ <%= form.date_field :start_date,
+ value: params[:start_date] || @start_date,
+ min: PersonalStatSnapshot.tracking_start_date,
+ max: PersonalStatSnapshot.tracking_end_date,
+ class: "date-input-inline" %>
+
+ ->
+
+ <%= form.date_field :end_date,
+ value: params[:end_date] || @end_date,
+ min: PersonalStatSnapshot.tracking_start_date,
+ max: PersonalStatSnapshot.tracking_end_date,
+ class: "date-input-inline" %>
+
+
+
(<%= @total_days_tracked %> days)
+
+ <%= hidden_field_tag :sort, params[:sort] %>
+ <%= hidden_field_tag :direction, params[:direction] %>
+
+
Apply
+ <% if params[:start_date].present? || params[:end_date].present? %>
+ <%= link_to "Reset", faction_path(@faction) + "#training", class: "filter-reset-inline" %>
+ <% end %>
+
+ <% end %>
+
+
+ <% if backfill_in_progress %>
+ <%= render "factions/training/table_skeleton" %>
+ <% else %>
+
+
+ Targets:
+ Xanax <%= @xanax_target %>/day
+ ·
+ Energy <%= energy_enabled ? "#{@energy_target}/day" : "Off" %>
+ ·
+ Nerve <%= nerve_enabled ? "#{@nerve_target}/day" : "Off" %>
+
+
+
+
+ <%= @compliant_members_count %>
+ Compliant
+
+
+ <%= @warning_members_count %>
+ Needs Attention
+
+
+ <%= @non_compliant_members_count %>
+ Below Target
+
+
+
+
+ <% if @member_rows.empty? %>
+
+
No data available for the selected period. Members need at least 2 snapshots to calculate gains.
+
+ <% else %>
+
+
+
+
+ Status
+ <%= sortable_header(sort_link("name", "MEMBER"), @faction) %>
+ <%= sortable_header(sort_link("xanax_daily", "XANAX"), @faction) %>Target: <%= @xanax_target %>/day
+ <%= sortable_header(sort_link("energy_refills_daily", "ENERGY REFILLS"), @faction) %>Target: <%= energy_enabled ? "#{@energy_target}/day" : "Disabled" %>
+ <%= sortable_header(sort_link("nerve_refills_daily", "NERVE REFILLS"), @faction) %>Target: <%= nerve_enabled ? "#{@nerve_target}/day" : "Disabled" %>
+ <%= sortable_header(sort_link("missions_daily", "CONTRACTS"), @faction) %>
+ <%= sortable_header(sort_link("crimes_daily", "CRIMES"), @faction) %>
+ <%= sortable_header(sort_link("activity_time_daily", "ACTIVITY"), @faction) %>min/day
+
+
+
+ <% @member_rows.each do |row| %>
+
+
+
+ <%= compliance_icon(row[:compliance_level]) %>
+
+
+
+ <%= row[:name] %>
+ <% if row[:ssl_user] %>
+ SSL
+ <% end %>
+
+
+
+ <% if row[:ssl_user] %>
+ <%= number_with_delimiter(row[:xanax_gained]) %>
+ Exempt
+ <% else %>
+ <%= number_with_delimiter(row[:xanax_gained]) %>
+
+ <%= row[:xanax_daily] %>/day
+
+ <% end %>
+
+
+
+
+ <%= number_with_delimiter(row[:energy_refills_gained]) %>
+
+ <%= row[:energy_refills_daily] %>/day
+
+
+
+
+
+ <%= number_with_delimiter(row[:nerve_refills_gained]) %>
+
+ <%= row[:nerve_refills_daily] %>/day
+
+
+
+
+
+ <%= number_with_delimiter(row[:missions_gained]) %>
+ <%= row[:missions_daily] %>/day
+
+
+
+
+ <%= number_with_delimiter(row[:crimes_gained]) %>
+ <%= row[:crimes_daily] %>/day
+
+
+
+
+ <%= number_with_delimiter(row[:activity_time_gained]) %> min
+ <%= row[:activity_time_daily] %> min/day
+
+
+
+
+
+
+
+
+
+ <% end %>
+
+
+
+ <% end %>
+ <% end %>
+
diff --git a/app/views/factions/_war_section.html.erb b/app/views/factions/_war_section.html.erb
new file mode 100644
index 0000000..f6193bb
--- /dev/null
+++ b/app/views/factions/_war_section.html.erb
@@ -0,0 +1,152 @@
+
+
+ <% if @current_war %>
+ <% if @api_keys_configured %>
+ <%= render "factions/ranked_wars/live_dashboard", war: @current_war, faction: @faction, war_data: @war_data %>
+ <% else %>
+
+
+
+
War in Progress
+
vs <%= @current_war.opponent_faction_name %>
+
+ <%= @current_war.our_score %>
+ -
+ <%= @current_war.their_score %>
+ / <%= @current_war.target_score %>
+
+
Live tracking is not available. Ask your faction leadership to configure API keys to enable live war tracking.
+
+
+ <% end %>
+ <% elsif @latest_war %>
+
+
+
+
+
+
+ <%= @faction.name %>
+ <%= @latest_war.our_score %>
+
+
+ Target
+ <%= @latest_war.target_score %>
+
+
+ <%= @latest_war.opponent_faction_name %>
+ <%= @latest_war.their_score %>
+
+
+
+
+
+ Attacks
+
+ <%= number_with_delimiter(@latest_war.our_attacks) %>
+ vs
+ <%= number_with_delimiter(@latest_war.their_attacks) %>
+
+
+
+ Avg Respect/Hit
+
+ <%= @latest_war.score_per_attack %>
+ vs
+ <%= @latest_war.their_score_per_attack %>
+
+
+ <% if @latest_war.rank_before && @latest_war.rank_after %>
+
+ Rank
+
+ <%= @latest_war.rank_before %>
+ <%= @latest_war.rank_change %>
+ <%= @latest_war.rank_after %>
+
+
+ <% end %>
+ <% if @latest_war.respect_gained.to_i > 0 || @latest_war.points_gained.to_i > 0 %>
+
+ Rewards
+
+ <% if @latest_war.respect_gained.to_i > 0 %>
+ +<%= number_with_delimiter(@latest_war.respect_gained) %> respect
+ <% end %>
+ <% if @latest_war.points_gained.to_i > 0 %>
+ +<%= @latest_war.points_gained %> points
+ <% end %>
+
+
+ <% end %>
+
+
+ <% top_performers = @latest_war.our_top_performers(3).select { |m| m["attacks"].to_i > 0 } %>
+ <% if top_performers.any? %>
+
+ <% end %>
+
+
+
+
+ <% else %>
+
+
+
+
No Ranked Wars
+
No ranked war data has been recorded yet. Wars will appear here once your faction participates in ranked warfare.
+
+
+ <% end %>
+
diff --git a/app/views/factions/leadership/_hero_section.html.erb b/app/views/factions/leadership/_hero_section.html.erb
new file mode 100644
index 0000000..489f1c9
--- /dev/null
+++ b/app/views/factions/leadership/_hero_section.html.erb
@@ -0,0 +1,150 @@
+
+
+
+
+
+ <%= link_to faction_leadership_war_history_path(@faction), class: "dashboard-stat-card dashboard-stat-card-link" do %>
+
+
+
+
+
+ <%= @wins %> W
+ /
+ <%= @losses %> L
+
+
War Record <%= Date.current.year %>
+ <% end %>
+
+ <%= link_to faction_leadership_spy_reports_path(@faction), class: "dashboard-stat-card dashboard-stat-card-link" do %>
+
+
+
+
+
<%= @spy_report_count %>
+
Spy Reports
+ <% end %>
+
+ <%= link_to faction_leadership_settings_path(@faction), class: "dashboard-stat-card dashboard-stat-card-link" do %>
+
+
+
+
+
<%= @leadership_users.count %>
+
Settings
+ <% end %>
+
+ <%= link_to faction_leadership_war_reports_path(@faction), class: "dashboard-stat-card dashboard-stat-card-link" do %>
+
+
+
+
+
<%= @wars.size %>
+
RW Payouts
+ <% end %>
+
+ <% if @war_polling_active %>
+ <%= button_to stop_faction_leadership_war_polling_path(@faction), method: :delete, class: "dashboard-stat-card dashboard-stat-card-link dashboard-stat-card-toggle", data: { turbo_confirm: "Stop war polling?" } do %>
+
+
+
+
+
+ Active
+
+
War Polling
+ <% end %>
+ <% else %>
+ <%= button_to start_faction_leadership_war_polling_path(@faction), method: :post, class: "dashboard-stat-card dashboard-stat-card-link dashboard-stat-card-toggle dashboard-stat-card-cta" do %>
+
+
+
+
+
+ Start
+
+
War Polling
+ <% end %>
+ <% end %>
+
+ <%= link_to faction_leadership_data_coverage_path(@faction), class: "dashboard-stat-card dashboard-stat-card-link" do %>
+
+
+
+
+
+ <% coverage_class = if @data_coverage_rate >= 90
+ "stat-compliant"
+ elsif @data_coverage_rate >= 70
+ "stat-warning"
+ else
+ "stat-danger"
+ end %>
+ <%= @data_coverage_rate %>%
+
+
Data Coverage
+ <% end %>
+
+ <%= link_to faction_leadership_activity_path(@faction), class: "dashboard-stat-card dashboard-stat-card-link" do %>
+
+
+
+
+ <% if @activity_ready %>
+
<%= @activity_days %> days
+ <% else %>
+
+
+ <% end %>
+
Member Activity
+ <% end %>
+
+ <%= link_to faction_leadership_armory_path(@faction), class: "dashboard-stat-card dashboard-stat-card-link" do %>
+
+
+
+
+ <% if @armory_loaned_count %>
+
<%= @armory_loaned_count %>
+ <% end %>
+
Items Loaned
+ <% end %>
+
+ <%= link_to faction_leadership_api_logs_path(@faction), class: "dashboard-stat-card dashboard-stat-card-link" do %>
+
+
+
+
+
+ <%= @api_peak_rate %>/min
+
+
API Peak Rate
+ <% end %>
+
+
diff --git a/app/views/factions/leadership/_leadership_access.html.erb b/app/views/factions/leadership/_leadership_access.html.erb
new file mode 100644
index 0000000..cc1373a
--- /dev/null
+++ b/app/views/factions/leadership/_leadership_access.html.erb
@@ -0,0 +1,40 @@
+<% if @faction_members.any? %>
+ <%= form_with url: faction_leadership_leadership_access_path(@faction), method: :post, class: "whitelist-add-form" do |form| %>
+
+ <%= form.select :user_id,
+ options_from_collection_for_select(@faction_members, :id, :name),
+ { prompt: "Select a member..." },
+ class: "whitelist-select" %>
+ <%= form.submit "Grant Access", class: "btn-primary" %>
+
+ <% end %>
+<% else %>
+ All faction members already have access.
+<% end %>
+
+<% if @leadership_users.any? %>
+
+<% else %>
+ No members have been granted access yet.
+<% end %>
diff --git a/app/views/factions/leadership/activity/show.html.erb b/app/views/factions/leadership/activity/show.html.erb
new file mode 100644
index 0000000..f09e09e
--- /dev/null
+++ b/app/views/factions/leadership/activity/show.html.erb
@@ -0,0 +1,163 @@
+
+ <%= link_to "← Back to Leadership".html_safe, faction_leadership_path(@faction), class: "back-link" %>
+
+
+
+
+ Heatmap
+ Chain Coverage
+ Members
+
+
+ <%# ── Tab 1: Calendar Heatmap ── %>
+
+
+
Active members (Online + Idle) by hour and day. Last 14 days. Times in TCT.
+ <% current_hour = Time.current.hour %>
+
+
+
+
+ <%= hour.to_s.rjust(2, "0") %>
+ <% end %>
+
+
+
+ <% @dates.reverse.each do |date| %>
+ <% is_today = date == Date.current %>
+ <% has_data = date >= @first_data_date %>
+
+
+ <%= is_today ? "Today" : date.strftime("%a") %>
+ <%= date.strftime("%d %b") %>
+
+ <% (0..23).each do |hour| %>
+ <% is_future = is_today && hour > current_hour %>
+ <% no_data = !has_data || is_future %>
+ <% count = @calendar[[date.to_s, hour]] || 0 %>
+ <% rgb = no_data ? "40, 40, 40" : activity_cell_rgb(count, @max_heatmap_value) %>
+ ">
+ <%= no_data ? '' : count %>
+
+ <% end %>
+
+ <% end %>
+
+
+
+
+
+ 0
+ All
+
+
+
+
+ <%# ── Tab 2: Chain Coverage ── %>
+
+
+
Average active members per hour across the last 14 days. Red bars indicate chain risk.
+
+ <% if @danger_windows.any? %>
+
+
Danger Windows
+
+ <% @danger_windows.each do |window| %>
+
+
+ <%= window[:start_hour].to_s.rjust(2, "0") %>:00 - <%= window[:end_hour].to_s.rjust(2, "0") %>:00 TCT
+
+
+ <%= window[:duration] %>h window
+ avg <%= window[:avg] %> active, min <%= window[:min] %>
+
+
+ <% end %>
+
+
+ <% end %>
+
+
+ <% @hourly_avg.each do |h| %>
+ <% pct = @member_count > 0 ? (h[:avg].to_f / @member_count * 100).round(1) : 0 %>
+ <% bar_color = if pct < 10
+ "rgb(239, 68, 68)"
+ elsif pct < 25
+ "rgb(249, 115, 22)"
+ elsif pct < 50
+ "rgb(234, 179, 8)"
+ else
+ "rgb(34, 197, 94)"
+ end %>
+
+
<%= h[:hour].to_s.rjust(2, "0") %>:00
+
+
<%= h[:avg].round %>
+
+ <% end %>
+
+
+
+
+ <%# ── Tab 3: Members ── %>
+
+
+
When each member is typically active. Last 7 days. Times in TCT.
+
+
+
+
+
+ Member
+
+
+
+
+ <% @members.each do |member| %>
+ <% hourly = @member_hourly[member.torn_member_id] || {} %>
+
+
+ <% if @has_enough_data %>
+
+ <%= member.member_name %>
+
+ <% else %>
+ <%= member.member_name %>
+ <% end %>
+
+
+
+ <% (0..23).each do |hour| %>
+ <% intensity = hourly[hour] || 0 %>
+ <% rgb = activity_cell_rgb((intensity * 100).to_i, 100) %>
+
+ <% end %>
+
+
+ <% end %>
+
+
+
+
+
+
+
+
+
+
Total Calls
+
<%= number_with_delimiter(@total_calls) %>
+
+
+
+
Calls Today
+
<%= number_with_delimiter(@calls_today) %>
+
+
+
+
Last 24 Hours
+
<%= number_with_delimiter(@calls_last_24h) %>
+
+
+
+
Success Rate
+
+ <%= @total_calls > 0 ? "#{((@successful_calls.to_f / @total_calls) * 100).round(1)}%" : "N/A" %>
+
+
+
+
+
Avg Response Time
+
<%= @avg_response_time ? "#{@avg_response_time}ms" : "N/A" %>
+
+
+
+
Failed Calls
+
<%= number_with_delimiter(@failed_calls) %>
+
+
+
+
Peak Rate Today
+
+ <%= @peak_rate_today[:rate] %>/min
+
+ <% if @peak_rate_today[:minute_start].present? %>
+
at <%= @peak_rate_today[:minute_start] %>
+ <% end %>
+
+
+
Recent API Calls (Last 500)
+
+ <% if @api_logs.any? %>
+
+
+
+ TIMESTAMP
+ ENDPOINT
+ SELECTIONS
+ STATUS
+ RESPONSE TIME
+ ERROR
+
+
+
+ <% @api_logs.each do |log| %>
+ <% selections = log.selections.present? ? JSON.parse(log.selections) : {} %>
+
+ <%= log.created_at.strftime("%d-%m-%Y %H:%M:%S") %>
+ <%= log.endpoint %>
+ <% if selections.any? %>
+ <% selections.each do |key, value| %>
+
+ <%= key %>:
+ <% if key == "timestamp" && value.is_a?(Integer) %>
+ <%= Time.at(value).utc.strftime("%d-%m-%Y") %>
+ <% else %>
+ <%= value.to_s %>
+ <% end %>
+
+ <% end %>
+ <% else %>
+ -
+ <% end %>
+
+
+
+ <%= log.status.upcase %>
+
+
+ <%= log.response_time ? "#{log.response_time}ms" : "N/A" %>
+ <%= log.error_message&.truncate(50) || "-" %>
+
+ <% end %>
+
+
+ <% else %>
+
No API calls recorded for this faction's key.
+ <% end %>
+
+ <%= link_to "← Back to Leadership".html_safe, faction_leadership_path(@faction), class: "back-link" %>
+
+
+
+ <% if @backfill_in_progress %>
+
+
+
+
+ Fetching armoury history Doing a data backfill up until 1 January 2026, because of Torn API v1 call constraints this backfill is spread across 10 days. The earliest Armoury Activity date is <%= earliest ? earliest.strftime("%d %b %Y") : "pending" %> .
+
+
+
+ <% end %>
+
+ <% if @members.any? %>
+
+
+
+
+
+
Armor Set
+
+ Assault
+ Delta
+ Riot
+ Dune
+ Combat
+ Other
+
+
+
+
Duplicates
+
+ Armor
+ Weapons
+ Both
+
+
+
+
+
+
+
+ <% if @armory_news.any? %>
+
+
+
+ <% @armory_news.each do |entry| %>
+
">
+ <%= entry[:text].html_safe %>
+ <%= Time.at(entry[:timestamp]).strftime("%H:%M %d/%m") %>
+
+ <% end %>
+
+
+ <% end %>
+
+
+ <% else %>
+
No members currently have loaned items.
+ <% end %>
+
+ <%= link_to "← Back to Leadership", faction_leadership_path(@faction), class: "back-link" %>
+
+
+
+
Overall Coverage
+
+ <% coverage_class = if @data_coverage_rate >= 90
+ "stat-compliant"
+ elsif @data_coverage_rate >= 70
+ "stat-warning"
+ else
+ "stat-danger"
+ end %>
+ <%= @data_coverage_rate %>%
+
+
+
+
+
Missing Yesterday
+
+ <% if @data_missing_yesterday > 0 %>
+ <%= @data_missing_yesterday %>
+ <% else %>
+ 0
+ <% end %>
+
+
+
+
+
Total Missing Days
+
+ <% if @data_total_missing_days > 0 %>
+ <%= number_with_delimiter(@data_total_missing_days) %>
+ <% else %>
+ 0
+ <% end %>
+
+
+
+
+
Tracking Period
+
<%= @tracking_start.strftime("%d %b") %> – <%= @tracking_end.strftime("%d %b %Y") %>
+
+
+
+
Next Backfill
+
+ --:--:--
+
+
Daily at 03:00 TCT
+
+
+
+
+
Members With Gaps (<%= @member_coverage.size %>)
+
+ <% if @member_coverage.any? %>
+
+
+
+
+ Member
+ Coverage
+ Days Present
+ Days Missing
+
+
+ <% @member_coverage.each do |member| %>
+
+
+
+
+ <%= member[:user].name %> [<%= member[:user].torn_id %>]
+
+
+
+ <% rate_class = if member[:rate] >= 90
+ "stat-compliant"
+ elsif member[:rate] >= 70
+ "stat-warning"
+ else
+ "stat-danger"
+ end %>
+ <%= member[:rate] %>%
+
+ <%= member[:existing] %>
+ <%= member[:missing] %>
+
+
+
+
+
Missing dates:
+
+ <% member[:missing_dates].each do |date| %>
+ <%= date.strftime("%d-%m-%Y") %>
+ <% end %>
+
+
+
+
+ <%= member[:missing] * 2 %> API calls needed to fetch <%= member[:missing] %> missing days.
+
+ <%= button_to "Backfill Now",
+ backfill_user_faction_leadership_data_coverage_path(@faction, user_id: member[:user].id),
+ method: :post,
+ class: "btn btn-sm btn-primary",
+ data: { action: "click->coverage-row#backfill", coverage_row_target: "button" } %>
+
+
+
+
+
+ <% end %>
+
+
+ <% else %>
+
+
All members have complete coverage!
+
+ <% end %>
+
+
+ <%= link_to "← Back to Leadership", faction_leadership_path(@faction), class: "back-link" %>
+
+
+
+
+
API Configuration
+
+
+
+
+ Torn API Key
+ <% if @torn_api_key&.access_type.present? %>
+ <%= @torn_api_key.access_type %>
+ <% end %>
+
+
+ <%= @torn_api_key_masked || "Not set" %>
+ <% if @torn_api_key.present? %>
+ <%= button_to faction_leadership_api_keys_path(@faction, key: "torn"),
+ method: :delete,
+ class: "leadership-key-delete-btn",
+ data: { turbo_confirm: "Delete the Torn API key?" } do %>
+
+
+ <% end %>
+ <% end %>
+
+
+
+
+
+ TornStats API Key
+
+
+ <%= @tornstats_api_key_masked || "Not set" %>
+ <% if @tornstats_api_key.present? %>
+ <%= button_to faction_leadership_api_keys_path(@faction, key: "tornstats"),
+ method: :delete,
+ class: "leadership-key-delete-btn",
+ data: { turbo_confirm: "Delete the TornStats API key?" } do %>
+
+
+ <% end %>
+ <% end %>
+
+
+
+
+ <%= form_with model: @faction_setting, url: faction_leadership_api_keys_path(@faction), method: :patch, class: "leadership-api-form" do |form| %>
+
+ <%= form.text_field :torn_api_key,
+ class: "leadership-api-input",
+ placeholder: "New Torn API key (Limited Access)",
+ autocomplete: "off",
+ value: "" %>
+ <%= form.text_field :tornstats_api_key,
+ class: "leadership-api-input",
+ placeholder: "New TornStats API key",
+ autocomplete: "off",
+ value: "" %>
+
+ <%= form.submit "Save Keys", class: "btn btn-sm btn-primary" %>
+ <% end %>
+
+
+ <%= render "shared/api_tos_table", key_access_level: "Limited Access (required)" %>
+
+
+
+
Leadership Access
+
Control who can access this dashboard.
+
+ <%= turbo_frame_tag "leadership-access" do %>
+ <%= render "factions/leadership/leadership_access" %>
+ <% end %>
+
+
+
+
Faction Subscription
+
Manage your faction's subscription.
+
+
+ <% if @faction_subscription_active %>
+ Status: Active
+ Expires: <%= @faction_subscription_expires_at.strftime("%d %B %Y") %>
+ Days remaining: <%= @faction_subscription_days_remaining %>
+ <% else %>
+ Status: Inactive
+ <% end %>
+
+
+
+
How it works
+
+
+
+ 2
+ Each Xanax = 2 weeks personal balance
+
+
+ 3
+ Transfer personal weeks to faction below
+
+
+
+
+
+
+ Faction members
+ <%= @faction_member_count %>
+
+
+ 1 faction week costs
+ <%= pluralize(@faction_week_cost, "personal week") %>
+
+
+ Your personal balance
+ <%= pluralize(@subscription_weeks_remaining, "week") %>
+
+
+ You can add
+ <%= pluralize(@max_faction_weeks, "faction week") %>
+
+
+
+ <% if @max_faction_weeks > 0 %>
+ <%= form_with url: faction_leadership_subscriptions_path(@faction), method: :post do |form| %>
+
+ <%= form.number_field :weeks, required: true, min: 1, max: @max_faction_weeks, value: 1, class: "api-key-form-input", placeholder: "Faction weeks", inputmode: "numeric", style: "max-width: 100px;" %>
+ <%= form.submit "Transfer to Faction", class: "btn btn-sm btn-primary",
+ data: { turbo_confirm: "This will cost #{@faction_week_cost} personal week(s) per faction week. Continue?" } %>
+
+ <% end %>
+ <% else %>
+
No personal weeks available. Send Xanax to Bram [2728237] to get started.
+ <% end %>
+
+
+
+
+
+
Delete Faction Data
+
This will permanently delete:
+
+ All personal stat snapshots for faction members
+ All spy reports collected for this faction
+ All ranked war history
+ The faction API keys
+ Leadership access for all members
+
+
+ Subscription time will NOT be revoked. Members keep their remaining subscription. You can set up the faction again at any time.
+
+ <%= button_to "Delete Collected Data",
+ faction_leadership_faction_data_path(@faction),
+ method: :delete,
+ class: "btn btn-danger",
+ data: { turbo_confirm: "Are you sure? This will permanently delete all faction data. This action cannot be undone." } %>
+
+
+
+
+
+
+ <%= form_with model: @faction_setting, url: faction_leadership_setup_path(@faction), method: :patch, class: "setup-form" do |form| %>
+
+
+
+ Torn API Key
+ Required
+
+ <%= form.text_field :torn_api_key,
+ class: "setup-input",
+ placeholder: "Enter your Limited Access API key",
+ autocomplete: "off",
+ required: true %>
+
+ Must be a Limited Access key.
+ Create one in Torn
+
+
+
+
+
+ TornStats API Key
+ Optional
+
+ <%= form.text_field :tornstats_api_key,
+ class: "setup-input",
+ placeholder: "Enter your TornStats API key",
+ autocomplete: "off" %>
+
+ For spy data imports.
+ Get from TornStats
+
+
+
+
+
+ <%= form.submit "Complete Setup", class: "btn btn-primary btn-lg setup-submit" %>
+ <%= link_to "Cancel", faction_path(@faction), class: "setup-cancel" %>
+
+ <% end %>
+
+
+
+
+
+ What are these keys used for?
+
+
+
+
Torn API Key
+
Fetches live member status during ranked wars. Limited Access ensures minimal permissions. Your key is stored securely.
+
+
+
TornStats API Key
+
Imports spy reports for enemy factions - estimated battle stats like strength, defense, speed, and dexterity.
+
+
+
+
+
+ <%= render "shared/api_tos_table", key_access_level: "Limited Access (required)" %>
+
+
+ <%= render "factions/leadership/hero_section" %>
+
diff --git a/app/views/factions/leadership/spy_reports/show.html.erb b/app/views/factions/leadership/spy_reports/show.html.erb
new file mode 100644
index 0000000..d9ad953
--- /dev/null
+++ b/app/views/factions/leadership/spy_reports/show.html.erb
@@ -0,0 +1,107 @@
+
+ <%= link_to "← Back to Leadership", faction_leadership_path(@faction), class: "back-link" %>
+
+
+ <% if @faction.tornstats_api_key&.key.present? %>
+
+ <%= form_with url: faction_leadership_spy_imports_path(@faction), method: :post, class: "leadership-import-form" do |form| %>
+ Import:
+ <%= form.text_field :target_faction_id,
+ class: "leadership-import-input",
+ placeholder: "Faction ID",
+ autocomplete: "off",
+ inputmode: "numeric",
+ pattern: "[0-9]*" %>
+ <% if @can_import %>
+ <%= form.submit "Import", class: "btn btn-sm btn-secondary" %>
+ <% else %>
+
+
+ <%= @seconds_until_import %>s
+
+
+ <% end %>
+ <% end %>
+
+ <% if @current_war %>
+ <%= button_to fetch_enemy_faction_leadership_spy_reports_path(@faction),
+ method: :post, class: "btn btn-sm btn-primary",
+ data: { turbo_submits_with: '
+ <% else %>
+
+
Configure your TornStats API key in <%= link_to "Settings", faction_leadership_settings_path(@faction) %> to import spy data.
+ <% if @current_war %>
+
+ Fetch <%= @current_war.opponent_faction_name %>
+
+ <% end %>
+
+ <% end %>
+
+
+
+
+
Spy Reports (<%= @spy_report_count %>)
+
+
+
+
+ #
+ Torn ID
+ Strength
+ Defense
+ Speed
+ Dexterity
+ Total
+ Age
+
+
+
+ <% if @spy_reports.empty? %>
+
+
+
+
No spy reports imported yet.
+
+
+ <% else %>
+ <% @spy_reports.each_with_index do |report, index| %>
+
+ <%= index + 1 %>
+
+
+ <%= report.torn_id %>
+
+
+ <%= number_with_delimiter(report.strength) %>
+ <%= number_with_delimiter(report.defense) %>
+ <%= number_with_delimiter(report.speed) %>
+ <%= number_with_delimiter(report.dexterity) %>
+ <%= number_with_delimiter(report.total) %>
+ <%= report.spied_at ? time_ago_in_words(report.spied_at) + " ago" : "Unknown" %>
+
+ <%= button_to destroy_report_faction_leadership_spy_reports_path(@faction, report.id),
+ method: :delete,
+ class: "spy-delete-btn",
+ data: { turbo_confirm: "Delete spy report for #{report.torn_id}?" } do %>
+
+
+ <% end %>
+
+
+ <% end %>
+ <% end %>
+
+
+
+
+
+ <%= link_to "← Back to Leadership", faction_leadership_path(@faction), class: "back-link" %>
+
+ <%= turbo_frame_tag "war-history" do %>
+
+
+
+ <%= render "factions/ranked_wars/war_history_table", wars: @wars, faction: @faction %>
+ <%= render "factions/ranked_wars/member_performance_table", member_performance: @member_performance %>
+
+ <% end %>
+
+ <%= link_to "← Back to Leadership", faction_leadership_path(@faction), class: "back-link" %>
+
+
+
+ Completed Wars
+ <% if @wars.any? %>
+
+ <% @wars.each do |war| %>
+ <%= link_to faction_leadership_war_reports_path(@faction, war: war.torn_war_id),
+ class: "war-reports-item #{'war-reports-item-selected' if @selected_war&.id == war.id}" do %>
+
+ <%= war.won? ? 'W' : 'L' %>
+
+
+ <%= war.opponent_faction_name %>
+ <%= war.started_at.strftime("%d %b %Y") %>
+
+
<%= war.our_score %>-<%= war.their_score %>
+ <% end %>
+ <% end %>
+
No completed wars.
+ <% end %>
+
+
+ <% if @selected_war %>
+ <% attacks_count = @has_attacks ? @outgoing.count : 0 %>
+ <% total_respect = @has_attacks ? @outgoing.sum(:respect_gain) : 0 %>
+ <% avg_respect = attacks_count > 0 ? (total_respect / attacks_count).round(2) : 0 %>
+ <% avg_ff = attacks_count > 0 ? (@outgoing.average(:fair_fight)&.round(2) || 0) : 0 %>
+ <% total_assists = @has_attacks ? @member_stats.sum { |m| m[:assists] } : 0 %>
+ <% total_overseas = @has_attacks ? @member_stats.sum { |m| m[:overseas_hits] } : 0 %>
+ <% total_warlord = @has_attacks ? @member_stats.sum { |m| m[:warlord_hits] } : 0 %>
+ <% reward_items = @selected_war.our_rewards&.dig("items") || [] %>
+ <% has_prices = reward_items.any? { |i| i["market_price"] } %>
+ <% estimated_total = @selected_war.reward_estimated_value || (has_prices ? reward_items.sum { |i| (i["market_price"] || 0) * i["quantity"] } : nil) %>
+
+
+
+
vs <%= @selected_war.opponent_faction_name %>
+ <%= button_to fetch_attacks_faction_leadership_war_reports_path(@faction, war: @selected_war.torn_war_id),
+ method: :post, class: "btn btn-sm btn-secondary",
+ data: { turbo_submits_with: '
+
+
+ <%= @selected_war.won? ? 'VICTORY' : 'DEFEAT' %>
+
+ <%= @selected_war.our_score %> – <%= @selected_war.their_score %> / <%= @selected_war.target_score %>
+ <%= @selected_war.duration_formatted %>
+ <%= @selected_war.started_at.strftime("%d %b %Y %H:%M") %>
+
+
+
+
+ <%= attacks_count %>
+ Attacks
+
+
+ <%= number_with_delimiter(total_respect.round(0)) %>
+ Respect
+
+
+ <%= avg_respect %>
+ Avg Respect
+
+
+ <%= avg_ff %>
+ Avg FF
+
+
+ <%= @has_attacks ? @member_stats.size : 0 %>
+ Participants
+
+
+ <%= total_warlord %>
+ Warlord
+
+
+ <%= total_overseas %>
+ Overseas
+
+
+ <%= total_assists %>
+ Assists
+
+
+ <% if reward_items.any? %>
+
+ <% reward_items.each do |item| %>
+ <% price = item["market_price"] %>
+
+ <%= item["quantity"] %>x <%= item["name"].sub(" Cache", "") %>
+ <% if price %>
+ $<%= number_with_delimiter(price * item["quantity"]) %>
+ <% end %>
+
+ <% end %>
+ <% if estimated_total %>
+ = $<%= number_with_delimiter(estimated_total) %>
+ <% end %>
+
+ <% end %>
+
+ <% else %>
+
+
+
No completed wars found.
+
+
+ <% end %>
+
+
+ <% if @selected_war %>
+ <% if !@integrity_ok %>
+
+ Incomplete: <%= @integrity_message || "No attack data fetched yet" %>
+
+ <% end %>
+
+
+
+
+
+
+
+
+
+
+ Member
+ RW Hits
+ FF<1.25
+ FF<1.75
+ FF≥1.75
+ Overseas
+ Assists
+ Warlord
+ Respect
+ Avg
+ Payout
+
+
+ <% if @has_attacks %>
+ <% @member_stats.each do |member| %>
+
+
+
+
+ <%= member[:name] %>
+
+
+ <%= member[:hits] %>
+
+ <% if member[:ff_low] > 0 %>
+ <%= member[:ff_low] %>
+ <% else %>
+ 0
+ <% end %>
+
+
+ <% if member[:ff_mid] > 0 %>
+ <%= member[:ff_mid] %>
+ <% else %>
+ 0
+ <% end %>
+
+ <%= member[:ff_high] %>
+ <% if member[:overseas_hits] > 0 %>
+ <%= member[:overseas_hits] %>
+ <% else %>
+ 0
+ <% end %>
+
+
+ <% if member[:assists] > 0 %>
+ <%= member[:assists] %>
+ <% else %>
+ 0
+ <% end %>
+
+
+ <% if member[:warlord_hits] > 0 %>
+ <%= member[:warlord_hits] %>
+ <% else %>
+ 0
+ <% end %>
+
+ <%= number_with_delimiter(member[:respect].round(0)) %>
+ <%= member[:avg_respect] %>
+ —
+
+
+
+
+
+
+
+ Target
+ Result
+ Respect
+ FF
+ War
+ Warlord
+ Chain
+ Time
+
+
+
+ <% (@attacks_by_member[member[:torn_id]] || []).sort_by(&:started).each do |attack| %>
+
+
+
+ <%= attack.defender_name %>
+
+
+ <%= attack.result %>
+ <%= attack.respect_gain&.round(2) %>
+
+ <%= attack.fair_fight&.round(2) %>
+
+ <%= attack.war&.round(1) %>
+
+ <% if attack.used_warlord? %>
+ <%= attack.warlord&.round(2) %>
+ <% else %>
+ 1
+ <% end %>
+
+ <%= attack.chain %>
+ <%= Time.at(attack.started).strftime("%d %b %H:%M") %>
+
+ <% end %>
+
+
+
+
+
+ <% end %>
+ <% else %>
+
+
+
+
+ <% end %>
+
+
+
+
+ <%= war.our_score %>
+ <%= link_to faction.name, "https://www.torn.com/factions.php?step=profile&ID=#{faction.torn_id}", target: "_blank", class: "faction-link" %>
+
+
+
+
+ <% if war.scheduled? %>
+ Live
+ <% end %>
+
+
+ <%= war.our_score - war.their_score %>
+ /
+ <%= war.target_score %>
+
+
+
+
+
+ <%= war.their_score %>
+ <%= link_to war.opponent_faction_name, "https://www.torn.com/factions.php?step=profile&ID=#{war.opponent_faction_id}", target: "_blank", class: "faction-link" %>
+
+
+
+
+
+
+
+
+
Status
+
+ Okay
+ Hospital
+ Jail
+ Traveling
+ Abroad
+
+
+
+
Activity
+
+ Online
+ Idle
+ Offline
+
+
+
+
Max Stats
+
+ No limit
+
+
+
+
+
+
+
+
+ Member Performance (All Wars)
+ Syncing...
+
+
+
+
+
+ Member Performance <%= Date.current.year %>
+
+
+ <% if member_performance.any? %>
+
+ <% else %>
+
+
👤
+
No member performance data yet. Sync wars to see member statistics.
+
+ <% end %>
+
+
+ War History
+ Syncing...
+
+
+
+
+
+ Status
+ Opponent
+ Score
+ Duration
+ Attacks
+ Avg Respect
+ Rank
+ Rewards
+ Date
+
+
+
+ <% 5.times do %>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <% end %>
+
+
+
+
+ War History
+
+
+ <% if wars.empty? %>
+
+
⚔
+
No ranked wars found.
+
+ <% else %>
+
+ <% end %>
+
+
+
+
+ Your Faction
+ <%= @faction.name %>
+ <%= @war.our_score %>
+
+
+
+
Target: <%= @war.target_score %>
+ <% if @war.completed? %>
+
+ <%= @war.won? ? "VICTORY" : "DEFEAT" %>
+
+ <% elsif @war.in_progress? %>
+
LIVE
+ <% else %>
+
SCHEDULED
+ <% end %>
+
<%= @war.duration_formatted %>
+
+
+
+ Opponent
+ <%= link_to @war.opponent_faction_name, "https://www.torn.com/factions.php?step=profile&ID=#{@war.opponent_faction_id}", target: "_blank", class: "faction-link" %>
+ <%= @war.their_score %>
+
+
+
+ <% if @war.respect_gained.to_i > 0 || @war.points_gained.to_i > 0 %>
+
+ <% if @war.respect_gained.to_i > 0 %>
+
+ +<%= number_with_delimiter(@war.respect_gained) %>
+ respect
+
+ <% end %>
+ <% if @war.points_gained.to_i > 0 %>
+
+ +<%= @war.points_gained %>
+ points
+
+ <% end %>
+
+ <% end %>
+
+
+
+
Stats Comparison
+
+
+
+ <%= number_with_delimiter(@war.our_attacks) %>
+ Attacks
+ <%= number_with_delimiter(@war.their_attacks) %>
+
+
+ <%= @war.score_per_attack %>
+ Avg Respect/Hit
+ <%= @war.their_score_per_attack %>
+
+ <% if @war.rank_before && @war.rank_after %>
+
+
+
+ <%= @war.rank_before %>
+ <%= @war.rank_change %>
+ <%= @war.rank_after %>
+
+
+ Rank
+
+ <% end %>
+
+
+
+
+
+
+ <%= @faction.name %> (<%= @our_members.count { |m| m["attacks"].to_i > 0 } %> fighters)
+
+
+
+ <% if @our_non_participants.any? %>
+
+ <%= @our_non_participants.count %> non-participants
+
+ <% @our_non_participants.each do |member| %>
+
+ <%= link_to member["name"], "https://www.torn.com/profiles.php?XID=#{member["id"]}", target: "_blank", class: "player-link" %>
+
+ <% end %>
+
+
+ <% end %>
+
+
+
+
+ <%= @war.opponent_faction_name %> (<%= @their_members.count { |m| m["attacks"].to_i > 0 } %> fighters)
+
+
+
+
+
+
+
+
+
+
+
+
Welcome! You're the first person from your faction to use TornManager. Everyone in your faction will receive a 1-month free trial to explore all features. This key will be stored as the faction's API key and used to fetch member stats, ranked wars, and other faction data.
+
+
+ <%= form_with url: setup_faction_path(torn_id: @faction.torn_id), method: :post, class: "setup-form" do |form| %>
+
+
+
+ Limited Access API Key
+ Required
+
+ <%= form.text_field :api_key,
+ value: @api_key_prefill,
+ class: "setup-input",
+ placeholder: "Enter your Limited Access API key",
+ autocomplete: "off",
+ required: true %>
+
+ Must be a Limited Access key that belongs to you.
+ Create one in Torn
+
+
+
+
+
+ <%= form.submit "Set Up My Faction", class: "btn btn-primary btn-lg setup-submit" %>
+
+ <% end %>
+
+
+
+
+
+ What happens during setup?
+
+
+
+
Leadership permissions
+
You'll be granted leadership access since you're setting up the faction. You can invite others from the Leadership dashboard. Leaders and Co-leaders are added automatically.
+
+
+
Member sync
+
All faction members are synced from the Torn API so everyone can access the dashboard (1 API call, instant).
+
+
+
Ranked war history
+
War history is fetched in the background (~20 API calls).
+
+
+
Personal stats backfill
+
Stats are backfilled for all members from January 1st, 2026. This requires ~2 API calls per member per day and may take a while at the rate limit of 60 calls/min.
+
+
+
API key security
+
Your key is stored securely and only used for faction-related API calls. Limited Access keys cannot perform actions on your account. You can revoke it at any time.
+
+
+
+
+
+ <%= render "shared/api_tos_table", key_access_level: "Limited Access (required)" %>
+
+
+
+
+
+
+
Only your faction's Leader or Co-leader can complete the initial setup. Once done, all members automatically receive a 1-month free trial .
+
+
+
+ Ask your Leader or Co-leader to sign in to TornManager and complete the one-time setup.
+
+
+ Need help? Reach out to Bram [2728237] on Torn.
+
+
+
+
+
+ <%= link_to "Go to Settings", settings_path, class: "btn btn-primary btn-lg setup-submit" %>
+
+
+
+ <%= render "factions/hero_section" %>
+ <%= render "factions/war_section" %>
+ <%= render "factions/training_section" %>
+
diff --git a/app/views/factions/subscription_expired.html.erb b/app/views/factions/subscription_expired.html.erb
new file mode 100644
index 0000000..327d881
--- /dev/null
+++ b/app/views/factions/subscription_expired.html.erb
@@ -0,0 +1,22 @@
+
+
+
+
+
+
Your subscription has expired. An active subscription is required to access faction features like the training dashboard, ranked wars, and personal stats tracking.
+
+
+
+ Ask your faction leadership to share subscription time with you from the Leadership dashboard.
+
+
+
+
+
+ <%= link_to "Go to Settings", settings_path, class: "btn btn-primary btn-lg setup-submit" %>
+
+
+
+
+
Daily Targets
+
+ Xanax: <%= @faction.xanax_target %>/dayEnergy Refills: <%= @faction.energy_refill_target %>/dayNerve Refills: <%= @faction.nerve_refill_target %>/day
+
+
+
+
+
+
+
+ Status
+ MEMBER
+ XANAXTarget: <%= @faction.xanax_target %>/day
+ ENERGY REFILLSTarget: <%= @faction.energy_refill_target %>/day
+ NERVE REFILLSTarget: <%= @faction.nerve_refill_target %>/day
+ CONTRACTS
+ CRIMES
+ ACTIVITYmin/day
+
+
+
+ <% 10.times do %>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <% end %>
+
+
+
+ <%= link_to "← Back to Dashboard", faction_path(@faction), class: "back-link" %>
+
+
+
+
+ <%= render "factions/ranked_wars/war_history_table", wars: @wars, faction: @faction %>
+ <%= render "factions/ranked_wars/member_performance_table", member_performance: @member_performance %>
+
+
+
+
+
+ <%= form_with url: hall_of_famers_path, method: :get, class: "table-filter-form" do |form| %>
+
+
Tracking Period:
+
+
+ <%= form.date_field :start_date,
+ value: params[:start_date] || @earliest_date,
+ min: PersonalStatSnapshot.tracking_start_date,
+ max: PersonalStatSnapshot.tracking_end_date,
+ class: "date-input-inline" %>
+
+ →
+
+ <%= form.date_field :end_date,
+ value: params[:end_date] || @latest_date,
+ min: PersonalStatSnapshot.tracking_start_date,
+ max: PersonalStatSnapshot.tracking_end_date,
+ class: "date-input-inline" %>
+
+
+
(<%= @total_days_tracked %> days)
+
+ <%= hidden_field_tag :sort, params[:sort] %>
+ <%= hidden_field_tag :direction, params[:direction] %>
+
+
Apply
+ <% if params[:start_date].present? || params[:end_date].present? %>
+ <%= link_to "Reset", hall_of_famers_path, class: "filter-reset-inline" %>
+ <% end %>
+
+ <% end %>
+
+
+
+
+
+ <%= sortable_header(sort_link("name", "PLAYER")) %>
+ <%= sortable_header(sort_link("xanax_gained", "XANAX GAINED")) %>
+ <%= sortable_header(sort_link("energy_drinks_gained", "ENERGY DRINKS GAINED")) %>
+ <%= sortable_header(sort_link("networth_gained", "NETWORTH GAINED")) %>
+ <%= sortable_header(sort_link("total_se", "TOTAL SE")) %>
+ <%= sortable_header(sort_link("se_gained", "SE GAINED")) %>
+
+
+
+ <% @table_rows.each do |row| %>
+
+
+ <%= row[:name] %>
+
+
+ <%= number_with_delimiter(row[:xanax_gained]) %>
+ <% if @total_days_tracked > 0 %>
+ <%= row[:xanax_daily] %>/day
+ <% end %>
+
+
+ <%= number_with_delimiter(row[:energy_drinks_gained]) %>
+ <% if @total_days_tracked > 0 %>
+ <%= row[:energy_drinks_daily] %>/day
+ <% end %>
+
+
+ <%= number_to_currency(row[:networth_gained], precision: 0) %>
+ <% if @total_days_tracked > 0 %>
+ <%= number_to_currency(row[:networth_daily], precision: 0) %>/day
+ <% end %>
+
+
+ <%= number_with_delimiter(row[:total_se]) %>
+ <% if @total_days_tracked > 0 %>
+ <%= row[:se_daily] %>/day
+ <% end %>
+
+
+ <%= number_with_delimiter(row[:se_gained]) %>
+ <% if @total_days_tracked > 0 %>
+ <%= row[:se_daily] %> taken/day
+ <% end %>
+
+
+
+
+
+
+
+
+ <% end %>
+
+
+
+
+
TornManager
+ <%= link_to "Sign In", new_session_path, class: "hero-signin-button" %>
+
+
+
+
+
Comming Soon!
+
+
+
Professional Faction Management
+
+ TornManager gives faction leaders and members the tools to track compliance, dominate ranked wars, and run a tight operation.
+ Paired with a companion browser script for in-game overlays. Fully mobile-friendly.
+
+
+
+
+
+
Features
+
Everything your faction needs
+
From live war intelligence to daily training compliance, TornManager covers the full lifecycle of faction management.
+
+
+
+
Live War Dashboard
+
+ Real-time ranked war tracking with enemy status, hospital timers, travel countdowns, and online indicators.
+ Polls every 3 seconds during active wars. See who to hit and when.
+
+
+
+
+ Okay
+ Hospital
+ Traveling
+
+
+
+ Online
+ Idle
+ Offline
+
+
(10/10)
+
+
+
+
+
+
+
+
Training & Compliance
+
+ Track daily xanax, energy refills, nerve refills, missions, and crimes per member.
+ Compliance scores, color-coded status, and sortable training tables with configurable targets.
+
+
+
+
+ 0
+ Compliant
+
+
+ 0
+ Needs Attn
+
+
+ 0
+ Below Target
+
+
+
+
+
+
+
+
And much more
+
+
+
+
+
+
War History & Analytics
+
Full ranked war history with scores, attacks, respect per hit, rank changes, and member performance tables.
+
+
+
+
+
+
+
Spy Reports
+
Import spy data from TornStats. View estimated battle stats with strength and defense breakdowns.
+
+
+
+
+
+
+
Member Activity Tracker
+
14-day activity heatmap, chain coverage analysis with danger windows, and per-member hourly timelines.
+
+
+
+
+
+
+
Ranked War Payouts
+
Auto-estimate reward value from market prices. Configure faction cut and assist weighting. Export to clipboard.
+
+
+
+
+
+
+
Public War Lobbies
+
Share live war dashboards with allies. Password-protected or open, with inline editable spy stats.
+
+
+
+
+
+
+
Browser Userscript
+
Tampermonkey companion that enhances torn.com with war stat overlays and member details.
+
+
+
+
+
+
+
Armoury Management
+
See who has what gear loaned, color-coded by armor set. Full activity log with loan and return history per member.
+
+
+
+
+
+
+
Leadership Dashboard
+
API key management, access control, data coverage monitoring, war polling, and faction subscription management.
+
+
+
+
+
+
+
Fully Mobile Friendly
+
Every feature works on your phone. Manage your faction during wars, check compliance on the go.
+
+
+
+
+
+
+
+
+
Trust & Security
+
Your data, your control
+
Built with transparency and privacy as core principles.
+
+
+
+
Full API Key Transparency
+
Every API call made with your key is logged and visible to you. See exactly what data is being accessed, when, and how often. No hidden requests.
+
+
+
+
Built-in Rate Limiting
+
Automatic 1-second delay between API calls ensures TornManager never exceeds 60 requests per minute per key. Your key stays safe from rate limit violations.
+
+
+
+
GDPR Compliant
+
Full data export, one-click data deletion, transparent privacy policy. Your data is never sold or shared with third parties. You own your data.
+
+
+
+
+
+
Pricing
+
Simple, faction-wide pricing
+
One price covers your entire faction. No per-feature upsells, no hidden costs.
+
+
1 Xanax = 2 weeks
+
personal balance, transferable to your faction
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
14-day free trial for new factions
+
+
+
+
+
In Development
+
What I'm building next
+
TornManager is actively developed. Here's what's coming soon.
+
+
+
Battle Stat Estimation
+
ML-powered stat predictions using spy data and player activity. Trained on 11,000+ samples with Random Forest.
+
+
+
Chain Tracking
+
Monitor chain progress, timeout warnings, and member contributions in real time.
+
+
+
Organised Crimes 2.0
+
Crime team management with CPR tracking, cost analysis, and optimal team suggestions.
+
+
+
Discord Integration
+
War notifications, compliance alerts, and member updates pushed directly to your faction's Discord server.
+
+
+
+
+
+ Getting Started
+
Up and running in minutes
+
+
+
+
+
1
+
Sign in with Torn
+
Use your Torn API key to authenticate. No passwords, no Discord — just your Torn identity.
+
+
+
2
+
Leader sets up faction
+
A faction leader provides a Limited Access API key. TornManager starts syncing your faction's data automatically.
+
+
+
3
+
Start tracking
+
Your dashboard is live. Training compliance, war analytics, and member management — all in one place.
+
+
+
+
+
Ready to level up your faction?
+
Join the factions already using TornManager.
+ <%= link_to "Sign In", new_session_path, class: "landing-cta-button" %>
+
+ <%= link_to "Privacy Policy", legal_path(anchor: "privacy-policy") %>
+ <%= link_to "Terms of Service", legal_path(anchor: "terms-of-service") %>
+
+
+
+
+
+ <%= form_with url: key_log_show_path, method: :post, class: "key-log-form-centered", data: { controller: "keylog", turbo: false } do |form| %>
+
+ <%= form.label :api_key, "Your API Key", class: "form-label" %>
+ <%= form.text_field :api_key,
+ class: "form-input",
+ placeholder: "Enter your Torn API key",
+ autocomplete: "off",
+ data: {
+ keylog_target: "input",
+ action: "input->keylog#checkInput"
+ } %>
+
+
+
+ <%= render "shared/api_tos_table",
+ data_storage: "Not stored - fetched and displayed only",
+ key_storage: "Never stored / Not shared",
+ purpose: "View API key activity log (3 API calls)",
+ key_access_level: "Any access level" %>
+
+
+
+
+ <%= form.submit "View Activity Log",
+ class: "btn btn-primary btn-large",
+ data: { keylog_target: "submit" },
+ disabled: true %>
+ <% end %>
+
+
+
What you'll see:
+
+ Peak Usage: Maximum requests per minute (rate limit is 100/min)Request Breakdown: Types, selections, tools, and IP addressesDetailed Log: Last 300 API requests with timestampsRate Limit Warnings: Alerts if you're approaching or exceeding limits
+
+
+
+
+
+ Showing <%= @log_data.log.size %> recent API requests with key:
+ <%= @api_key %>
+
+ <%= link_to "← Check Another Key", key_log_path, class: "back-link" %>
+
+
+
Peak Usage
+
<%= peak_requests %>
+
requests/minute
+ <% if peak_minute %>
+
at <%= peak_minute.first %> UTC
+ <% end %>
+ <% if peak_requests >= 100 %>
+
⚠️ Rate limit exceeded!
+ <% elsif peak_requests >= 90 %>
+
⚠️ Close to rate limit
+ <% end %>
+
+
+
+
Total Requests
+
<%= logs.size %>
+
API calls
+
+
+
+
Unique IPs
+
<%= by_ip.size %>
+
IP addresses
+ <% if by_ip.size > 1 %>
+
Multiple IPs detected
+ <% end %>
+
+
+
+
API Categories
+
<%= by_type.size %>
+
types used
+
+
+
⚠️ Rate Limit Exceeded
+
+ Your API key exceeded Torn's rate limit of 100 requests per minute.
+
+
+ When you make 100 or more API requests in a single minute, Torn will block your IP address
+ and you'll receive a "You are being rate limited" error message. This protection prevents
+ server overload.
+
+
What to check:
+
+ Multiple tools/scripts: Check if you're running multiple tools that use your API key simultaneouslyPolling frequency: Reduce how often your tools fetch data from Torn's APIShared IP addresses: If you're on a shared network, others may be using Torn's API on the same IPBackground scripts: Look for forgotten scripts or automation still running
+
+ Solution: Review the "Tools/Services" and "IP Addresses" sections below to identify which
+ tools are making the most requests. Consider spacing out API calls or reducing polling frequency to stay under 100 requests per minute.
+
+
+
⚠️ Approaching Rate Limit
+
+ You're getting close to Torn's rate limit of 100 requests per minute.
+
+
+ Your peak usage is <%= peak_requests %> requests per minute. Torn will block your IP if you reach 100 or more
+ requests in a single minute. Review your API usage below to prevent being rate limited.
+
+
+
+
Requests by Type
+
+ <% by_type.each do |type, count| %>
+
+ <%= type %>
+
+ <%= count %> (<%= (count.to_f / logs.size * 100).round(1) %>%)
+
+ <% end %>
+
+
+
+
+
Top Selections
+
+ <% by_selections.each do |selection, count| %>
+
+ <%= selection %>
+
+ <%= count %> (<%= (count.to_f / logs.size * 100).round(1) %>%)
+
+ <% end %>
+
+
+
+ <% if by_comment.any? %>
+
+
Tools/Services
+
+ <% by_comment.each do |comment, count| %>
+
+ <%= comment %>
+
+
+ <%= count %> (<%= (count.to_f / logs.size * 100).round(1) %>%)
+
+ <% end %>
+
+
+ <% end %>
+
+
+
IP Addresses
+
+ <% by_ip.each do |ip, count| %>
+
+ <%= ip %>
+
+
+ <%= count %> (<%= (count.to_f / logs.size * 100).round(1) %>%)
+
+ <% end %>
+
+
+
Detailed Request Log
+
+
+
+
+ Timestamp
+ Type
+ Selections
+ ID
+ IP Address
+ Comment
+
+
+
+ <% @log_data.log.each do |entry| %>
+
+ <%= Time.at(entry.timestamp).utc.strftime("%d-%m-%Y %H:%M:%S") %>
+ <%= entry.type %><%= entry.selections %><%= entry.id || "-" %>
+ <%= entry.ip %>
+ <%= entry.comment || "-" %>
+
+ <% end %>
+
+
+
+
No recent API activity found for this key.
+
+
+
+ What Am I Looking At?
+
+ Peak Usage: Maximum number of requests made in any single minuteRequests by Type: Distribution of API calls across different categories (user, key, faction, etc.)Top Selections: Most frequently accessed endpointsTools/Services: Applications identified by their comment fieldIP Addresses: Which IPs are accessing your API key
+
+ Detailed Log Fields
+
+ Timestamp: When the API request was made (UTC)Type: The API category (user, key, faction, torn, etc.)Selections: Which specific data was requestedID: The target ID if applicable (e.g., user ID)IP Address: The IP address that made the requestComment: Optional comment identifying the tool/service
+
+
+
Security Tip: If you see unfamiliar IP addresses or selections you don't recognize, consider regenerating your API key on Torn.com.
+
+
+
+
+ <% if type == 'notice' %>
+
+
+ <% else %>
+
+
+ <% end %>
+
+
<%= message %>
+
+
+
+
+
+
- <%= render "layouts/navbar" %>
-
+<% if authenticated? %>
+
+ <%= render "layouts/navbar" %>
+
+<% end %>
diff --git a/app/views/layouts/_navbar.html.erb b/app/views/layouts/_navbar.html.erb
index 02339e5..4bc5eb9 100644
--- a/app/views/layouts/_navbar.html.erb
+++ b/app/views/layouts/_navbar.html.erb
@@ -1,8 +1,125 @@
-
+
<% if authenticated? %>
- <%= link_to "TornManager", progress_index_path, class: "navbar-link navbar-title" %>
- <%= link_to "[p] My Progress", progress_index_path, class: "navbar-link" %>
- <%= link_to "[f] My Faction", faction_index_path, class: "navbar-link" %>
- <%= link_to "[r] Ranked War", ranked_war_index_path, class: "navbar-link" %>
+
+ <%= link_to "TornManager", Current.user&.faction ? factions_path : root_path, class: "navbar-link navbar-title" %>
+
+
+
+ <% if navbar_faction %>
+
+
+ <%= viewing_other_faction? ? navbar_faction.name : "My Faction" %>
+
+
+
+
+ <%= link_to "Dashboard", faction_path(navbar_faction), class: "navbar-dropdown-item" %>
+ <%= link_to "Leadership", faction_leadership_path(navbar_faction), class: "navbar-dropdown-item" %>
+
+
+ <% else %>
+ <%= link_to "My Faction", factions_path, class: "navbar-link #{'navbar-link-active' if request.path.start_with?('/factions')}" %>
+ <% end %>
+ <% if Current.user&.hof_access? %>
+ <%= link_to "Hall of Famers", hall_of_famers_path, class: "navbar-link #{'navbar-link-active' if request.path.start_with?('/hall-of-famers')}" %>
+ <% end %>
+ <%= link_to "Public Wars", public_wars_path, class: "navbar-link #{'navbar-link-active' if request.path.start_with?('/public_wars')}" %>
+ <% if Current.user&.admin? %>
+ <%= link_to "Admin", admin_dashboard_path, class: "navbar-link #{'navbar-link-active' if request.path.start_with?('/admin')}" %>
+ <% end %>
+
+
+ <% if Current.user.profile_image.present? %>
+
+ <% end %>
+
+ <%= Current.user.name %>
+
+
+
+
+ <%= link_to "API Calls", user_api_calls_path, class: "navbar-dropdown-item" %>
+ <%= link_to "Stocks", stocks_path, class: "navbar-dropdown-item" %>
+ <%= link_to "Settings", settings_path, class: "navbar-dropdown-item" %>
+ <%= link_to "Join Discord", "https://discord.gg/JpuNR2qTyn", target: "_blank", class: "navbar-dropdown-item" %>
+ <%= button_to "Sign Out", session_path, method: :delete, class: "navbar-dropdown-item navbar-dropdown-signout" %>
+
+
+
+ <% if Current.user.profile_image.present? %>
+
+ <% end %>
+
+
+
+
+
+
+ <%= link_to "TornManager", root_path, class: "navbar-link navbar-title" %>
+
+
+ <%= link_to "Public Wars", public_wars_path, class: "navbar-link #{'navbar-link-active' if request.path.start_with?('/public_wars')}" %>
+ <%= link_to "Key Activity Log", key_log_path, class: "navbar-link #{'navbar-link-active' if request.path.start_with?('/key-log')}" %>
+
+
+ <%= link_to "Sign In", new_session_path, class: "navbar-signin" %>
+
+
+
+
+
+
+
+
+
<% end %>
diff --git a/app/views/layouts/application.html.erb b/app/views/layouts/application.html.erb
index e8f7a5e..5225525 100644
--- a/app/views/layouts/application.html.erb
+++ b/app/views/layouts/application.html.erb
@@ -11,12 +11,8 @@
<%= yield :head %>
- <%# Enable PWA manifest for installable apps (make sure to enable in config/routes.rb too!) %>
- <%#= tag.link rel: "manifest", href: pwa_manifest_path(format: :json) %>
-
+ <% flash.each do |type, message| %>
+ <%= render "layouts/flash", type: type, message: message %>
+ <% end %>
+