rest-gw2 0.4.0 → 0.5.0

data/lib/rest-gw2/server/action.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require 'rest-gw2/server/imp'
+
+module RestGW2
+  class ServerAction
+    def self.weapons
+      %w[Greatsword Sword Hammer Mace Axe Dagger
+         Staff Scepter
+         Longbow Shortbow Rifle Pistol
+         Shield Torch Focus Warhorn
+         Spear Speargun Trident]
+    end
+
+    def self.armors
+      %w[Helm Shoulders Coat Gloves Leggings Boots HelmAquatic]
+    end
+
+    def self.armors_weight
+      %w[Light Medium Heavy Clothing]
+    end
+
+    def self.crafting
+      %w[Weaponsmith Huntsman Artificer
+         Armorsmith Leatherworker Tailor
+         Jeweler Chef Scribe]
+    end
+
+    include Jellyfish
+    controller_include NormalizedPath, ServerImp
+
+    handle Timeout::Error do
+      status 504
+      render :error, 'Timeout. Please try again.'
+    end
+
+    handle RestGW2::Error do |e|
+      status 502
+      render :error, e.error['text']
+    end
+
+    post '/access_token' do
+      t = encrypt(request.POST['access_token'])
+      r = request.POST['referrer']
+      u = if r == view.path('/') then view.path('/account') else r end
+      found "#{u}?t=#{t}"
+    end
+
+    get '/' do
+      render :index
+    end
+
+    get '/account' do
+      info = gw2_request(:account_with_detail).dup
+      %w[guilds guild_leader].each do |guild|
+        info[guild] = info[guild].map(&view.method(:show_guild))
+      end
+
+      render :info, info
+    end
+
+    get %r{\A/guilds/(?<uuid>[^/]+)\z} do |m|
+      guild_request(m[:uuid]) do |arg|
+        render :guild_info, arg.merge(:guild => arg.dig(:guilds, arg[:gid]))
+      end
+    end
+
+    get %r{\A/guilds/(?<uuid>[^/]+)/members\z} do |m|
+      guild_request(m[:uuid]) do |arg|
+        members = gw2_defer(:guild_members, arg[:gid])
+
+        render :members, arg.merge(:members => members)
+      end
+    end
+
+    get %r{\A/guilds/(?<uuid>[^/]+)/items\z} do |m|
+      guild_request(m[:uuid]) do |arg|
+        stash    = gw2_defer(   :stash_with_detail, arg[:gid])
+        treasury = gw2_defer(:treasury_with_detail, arg[:gid])
+
+        render :stash, arg.merge(:stash => stash, :treasury => treasury)
+      end
+    end
+
+    get '/characters' do
+      chars = gw2_request(:characters_with_detail)
+      total = chars.inject(0){ |t, c| t + c['age'] }
+      craftings = group_by_crafting(chars)
+
+      render :characters, :chars => chars, :total => total,
+                          :craftings => craftings
+    end
+
+    get %r{\A/characters/(?<name>[\w ]+)\z} do |m|
+      characters = gw2_request(:characters_with_detail)
+      names = characters.map { |c| c['name'] }
+      name  = m[:name]
+      char  = characters.find{ |c| c['name'] == name }
+      equi  = gw2_defer(:expand_item_detail, char['equipment'])
+      bags  = gw2_defer(:bags_with_detail  , char['bags'])
+
+      equi_buy, equi_sell = view.sum_items(equi)
+      bags_buy, bags_sell = view.sum_items(bags +
+                              bags.flat_map{ |c| c && c['inventory'] })
+
+      render :profile, :names => names, :equi => equi, :bags => bags,
+                       :equi_buy => equi_buy, :equi_sell => equi_sell,
+                       :bags_buy => bags_buy, :bags_sell => bags_sell
+    end
+
+    get '/items' do
+      render :items, gw2_request(:with_item_detail, 'v2/account/inventory')
+    end
+
+    get '/items/bank' do
+      render :items, gw2_request(:with_item_detail, 'v2/account/bank')
+    end
+
+    get '/items/materials' do
+      render :items, gw2_request(:with_item_detail, 'v2/account/materials')
+    end
+
+    get '/items/all' do
+      render :items, all_items
+    end
+
+    get %r{\A/items/(?<id>\d+)\z} do |m|
+      acct, bank, materials, chars = find_my_item(m[:id].to_i)
+      buy, sell = view.sum_items(acct + bank + materials +
+                                 chars.values.flatten)
+
+      render :items_from, :acct => acct, :bank => bank,
+                          :materials => materials, :chars => chars,
+                          :buy => buy, :sell => sell
+    end
+
+    get '/wallet' do
+      render :wallet, gw2_request(:wallet_with_detail)
+    end
+
+    get '/unlocks/skins/backpacks' do
+      skin_request('Back')
+    end
+
+    weapons.each do |weapon|
+      get "/unlocks/skins/weapons/#{weapon.downcase}" do
+        skin_request('Weapon', weapon)
+      end
+    end
+
+    get '/unlocks/skins/weapons/other' do
+      subtype = Regexp.new("\\A(?:#{Regexp.union(*ServerAction.weapons)})\\z")
+
+      skin_request('Weapon', 'Other') do |item|
+        item.dig('details', 'type') !~ subtype
+      end
+    end
+
+    armors.each do |armor|
+      armors_weight.each do |weight|
+        get "/unlocks/skins/armors/#{armor.downcase}/#{weight.downcase}" do
+          skin_request('Armor', armor, weight)
+        end
+      end
+    end
+
+    get '/unlocks/skins/armors/other' do
+      subtype = Regexp.new("\\A(?:#{Regexp.union(*ServerAction.armors)})\\z")
+
+      skin_request('Armor', 'Other') do |item|
+        item.dig('details', 'type') !~ subtype
+      end
+    end
+
+    get '/unlocks/skins/gathering' do
+      skin_request('Gathering')
+    end
+
+    get '/unlocks/dyes' do
+      dyes = gw2_request(:dyes_with_detail)
+      buy, sell = view.sum_items(dyes)
+      unlocked = dyes.count{ |d| d['count'] > 0 }
+
+      render :dyes, :dyes => dyes,
+                    :buy => buy, :sell => sell,
+                    :unlocked => unlocked
+    end
+
+    get '/unlocks/outfits' do
+      render :unlocks_items, gw2_request(:outfits_with_detail)
+    end
+
+    get '/unlocks/minis' do
+      render :unlocks_items, gw2_request(:minis_with_detail)
+    end
+
+    get '/unlocks/finishers' do
+      render :unlocks_items, gw2_request(:finishers_with_detail)
+    end
+
+    get '/unlocks/mailcarriers' do
+      render :unlocks_items, gw2_request(:mailcarriers_with_detail)
+    end
+
+    get '/unlocks/gliders' do
+      render :unlocks_items, gw2_request(:gliders_with_detail)
+    end
+
+    get '/unlocks/cats' do
+      render :unlocks_list, gw2_request(:cats_with_detail)
+    end
+
+    get '/unlocks/nodes' do
+      render :unlocks_list, gw2_request(:nodes_with_detail)
+    end
+
+    get '/achievements/titles' do
+      render :titles, gw2_request(:titles_with_detail)
+    end
+
+    get '/commerce/delivery' do
+      items = gw2_request(:delivery_with_detail, :page => view.query_p)
+      total = items.shift['price']
+
+      render :commerce, :items => items, :total => total
+    end
+
+    get '/commerce/buying' do
+      trans_request(:transactions_with_detail_compact, 'current/buys')
+    end
+
+    get '/commerce/selling' do
+      trans_request(:transactions_with_detail_compact, 'current/sells')
+    end
+
+    get '/commerce/bought' do
+      trans_request(:transactions_with_detail_compact, 'history/buys')
+    end
+
+    get '/commerce/sold' do
+      trans_request(:transactions_with_detail_compact, 'history/sells')
+    end
+
+    get '/exchange' do
+      # We try to spend 800 gems to buy golds as the standard for buying gold,
+      # and try to spend 100 golds to buy gems as the standard for buying gems
+      # Then we try to use those ratios to calculate the prices and match
+      # the information in the game. We also try to include the standard
+      # to the list, sorted it to the proper place.
+      # This is trying to match whatever the game is showing, and also show
+      # the real responses from the API.
+      gold_std, gem_std =
+        [stub_gold(800), stub_gem(100_00_00)].map(&method(:resolve_count))
+
+      buy_gold_coins_per_gem = gold_std['coins_per_gem']
+      buy_gold = [gold_std, 1, 10, 50, 100, 250].map do |gold|
+        case gold
+        when Numeric
+          coins = gold * 100_00
+          stub_gold((coins.to_f / buy_gold_coins_per_gem).round, coins)
+        else
+          gold
+        end
+      end.sort_by{ |g| g['count'] }
+
+      buy_gem_coins_per_gem = gem_std['coins_per_gem']
+      buy_gem = [gem_std, 400, 800, 1200, 2000].map do |gem|
+        case gem
+        when Numeric
+          stub_gem(gem * buy_gem_coins_per_gem, gem)
+        else
+          gem
+        end
+      end.sort_by{ |g| g['count'] }
+
+      render :exchange, :buy_gold => buy_gold, :buy_gem => buy_gem
+    end
+
+    get '/tokeninfo' do
+      render :info, gw2_request(:get, 'v2/tokeninfo')
+    end
+  end
+end

data/lib/rest-gw2/server/cache.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
 
 module RestGW2
   module Cache
+    EXPIRES_IN = 600
+    LRU_SIZE = 8192
+
     module_function
     def default logger
       @cache ||= Cache.pick(logger)
@@ -12,8 +16,8 @@ module RestGW2
 
     def memcache logger
       require 'dalli'
-      client = Dalli::Client.new
-      File.open(IO::NULL) do |null|
+      client = Dalli::Client.new(nil, :expires_in => EXPIRES_IN)
+      File.open(IO::NULL, 'w') do |null|
         Dalli.logger = Logger.new(null)
         client.alive!
         Dalli.logger = logger
@@ -28,8 +32,14 @@ module RestGW2
 
     def lru_cache logger
       require 'lru_redux'
-      logger.info("LRU cache size: 100")
-      LruRedux::ThreadSafeCache.new(100)
+      logger.info("LRU cache size: #{LRU_SIZE}")
+      cache = LruRedux::ThreadSafeCache.new(LRU_SIZE)
+      cache.extend(Module.new{
+        def fetch key # original fetch could deadlock
+          self[key] || self[key] = yield
+        end
+      })
+      cache
     rescue LoadError => e
       logger.debug("Skip LRU cache because: #{e}")
       nil

data/lib/rest-gw2/server/imp.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require 'rest-gw2/server/cache'
+require 'rest-gw2/server/view'
+require 'rest-gw2/client'
+
+require 'rest-core'
+require 'jellyfish'
+
+require 'uri'
+require 'timeout'
+require 'openssl'
+
+module RestGW2
+  module ServerImp
+    SECRET = ENV['RESTGW2_SECRET'] || 'RESTGW2_SECRET'*2
+
+    GemIcon = 'https://render.guildwars2.com/' \
+      'file/220061640ECA41C0577758030357221B4ECCE62C/502065.png'
+    GoldIcon = 'https://render.guildwars2.com/' \
+      'file/98457F504BA2FAC8457F532C4B30EDC23929ACF9/619316.png'
+
+    # VIEW
+    def view
+      @view ||= View.new(request, query_t)
+    end
+
+    def render *args
+      view.render(*args)
+    end
+
+    def all_items
+      acct, bank, mats, chars = all_items_defer
+      flatten_chars = chars.flat_map do |c|
+        c['equipment'] +
+          c['bags'] +
+          c['bags'].flat_map{ |c| c && c['inventory'] }
+      end
+      (acct + bank + mats + flatten_chars).compact.
+        sort_by{ |i| i['name'] || i['id'].to_s }.inject([]) do |r, i|
+          last = r.last
+          if last && last['id'] == i['id'] &&
+             last.values_at('skin', 'upgrades', 'infusions').compact.empty?
+            last['count'] += i['count']
+          else
+            r << i
+          end
+          r
+        end
+    end
+
+    def find_my_item id
+      acct, bank, mats, chars = all_items_defer
+      [select_item(acct.compact, id),
+       select_item(bank.compact, id),
+       select_item(mats.compact, id),
+       chars.inject({}){ |r, c|
+         equi = select_item(c['equipment'].compact, id)
+         bags = c['bags'].reject(&:nil?).map do |b|
+           selected = select_item(b['inventory'].compact, id)
+           b.merge('inventory' => selected) if selected.any? ||
+                                               b['id'] == id
+         end.compact
+         r[c['name']] = [equi, bags] if equi.any? || bags.any?
+         r
+       }]
+    end
+
+    def select_item items, id
+      items.select{ |i| i['id'] == id }
+    end
+
+    def all_items_defer
+      acct  = gw2_defer(:with_item_detail, 'v2/account/inventory')
+      bank  = gw2_defer(:with_item_detail, 'v2/account/bank')
+      mats  = gw2_defer(:with_item_detail, 'v2/account/materials')
+      chars = gw2_defer(:characters_with_detail).map do |c|
+        c['equipment'] = gw2_defer(:expand_item_detail, c['equipment'])
+        c['bags']      = gw2_defer(:bags_with_detail  , c['bags'])
+        c
+      end
+      [acct, bank, mats, chars]
+    end
+
+    # CONTROLLER
+    def gw2_request msg, *args
+      block ||= :itself.to_proc
+      refresh = !!request.GET['r']
+      opts = {'cache.update' => refresh, 'expires_in' => Cache::EXPIRES_IN}
+      args << {} if msg == :with_item_detail
+      key = cache_key(msg, args)
+      cache.delete(key) if refresh
+      cache.fetch(key) do
+        PromisePool::Future.resolve(gw2.public_send(msg, *args, opts))
+      end
+    end
+
+    def gw2_defer msg, *args
+      PromisePool::Promise.new.defer do
+        gw2_request(msg, *args)
+      end.future
+    end
+
+    def guild_request gid
+      guilds = gw2_request(:account_with_detail)['guilds'].
+        group_by{ |g| g['id'] }.inject({}){ |r, (id, v)| r[id] = v.first; r }
+
+      if guilds[gid]
+        yield(:gid => gid, :guilds => guilds)
+      else
+        status 404
+        render :error, "Cannot find guild id: #{gid}"
+      end
+    end
+
+    def skin_request type, subtype=nil, weight=nil, &block
+      items = gw2_request(:skins_with_detail).select do |i|
+        filter_skin(i, type, subtype, weight, &block)
+      end
+      skin_submenu = "menu_#{type.downcase}s" if subtype
+      subtype = subtype.downcase if subtype
+      weight = weight.downcase if weight
+      unlocked = items.count{ |i| i['count'] > 0 }
+
+      render :skins, :items => items,
+                     :skin_submenu => skin_submenu,
+                     :subtype => subtype,
+                     :weight => weight,
+                     :unlocked => unlocked
+    end
+
+    def filter_skin item, type, subtype, weight
+      item['type'] == type &&
+        if block_given?
+          yield(item)
+        else
+          (subtype.nil? || subtype == item.dig('details', 'type')) &&
+          (weight.nil? || weight == item.dig('details', 'weight_class'))
+        end
+    end
+
+    def trans_request msg, path
+      items = gw2_request(msg, path, :page => view.query_p)
+      total = view.sum_trans(items)
+      pages = calculate_pages("v2/commerce/transactions/#{path}")
+
+      render :commerce, :items => items, :total => total, :pages => pages
+    end
+
+    def group_by_crafting characters
+      characters.inject(Hash.new{|h,k|h[k]=[]}) do |group, char|
+        char['crafting'].each do |crafting|
+          group[crafting['discipline']] <<
+            [crafting['rating'], char['name'], crafting['active']]
+        end
+        group
+      end
+    end
+
+    def calculate_pages path
+      link = gw2.get(path, {:page_size => 200},
+                     RC::RESPONSE_KEY => RC::RESPONSE_HEADERS)['LINK']
+      pages = RC::ParseLink.parse_link(link)
+      parse_page(pages['first']['uri'])..parse_page(pages['last']['uri'])
+    end
+
+    def parse_page uri
+      RC::ParseQuery.parse_query(URI.parse(uri).query)['page'].to_i
+    end
+
+    def stub_gold num, count=nil
+      count ||=
+        gw2_request(:get, 'v2/commerce/exchange/gems', :quantity => num)
+
+      {'name' => 'Gold', 'icon' => GoldIcon, 'price' => num, 'count' => count}
+    end
+
+    def stub_gem num, count=nil
+      count ||=
+        gw2_request(:get, 'v2/commerce/exchange/coins', :quantity => num)
+
+      {'name' => 'Gem', 'icon' => GemIcon, 'price' => num, 'count' => count}
+    end
+
+    def resolve_count item
+      item['coins_per_gem'] = item['count']['coins_per_gem']
+      item['count'] = item['count']['quantity']
+      item
+    end
+
+    def gw2
+      @gw2 ||= Client.new(:access_token => access_token,
+                          :log_method => logger(env).method(:info),
+                          :cache => cache)
+    end
+
+    def cache
+      @cache ||= RestGW2::Cache.default(logger(env))
+    end
+
+    def cache_key msg, args
+      [msg, *args, access_token].join(':')
+    end
+
+    # ACCESS TOKEN
+    def access_token
+      query_t && decrypt(query_t) || ENV['RESTGW2_ACCESS_TOKEN']
+    rescue ArgumentError, OpenSSL::Cipher::CipherError => e
+      raise RestGW2::Error.new({'text' => e.message}, 0)
+    end
+
+    def query_t
+      @query_t ||= begin
+        r = request.GET['t']
+        r if r && !r.strip.empty?
+      end
+    end
+
+    # UTILITIES
+    def encrypt data
+      cipher = new_cipher
+      cipher.encrypt
+      cipher.key = SECRET
+      iv = cipher.random_iv
+      encrypted = cipher.update(data) + cipher.final
+      tag = auth_tag(cipher)
+      encode_base64(iv, encrypted, tag)
+    end
+
+    def decrypt data
+      iv, encrypted, tag = decode_base64(data)
+      cipher = new_cipher
+      cipher.decrypt
+      cipher.key = SECRET
+      cipher.iv = iv
+      set_auth_tag(cipher, tag)
+      cipher.update(encrypted) + cipher.final
+    end
+
+    def encode_base64 *data
+      data.map{ |d| [d].pack('m0') }.join('.').tr('+/=', '-_~')
+    end
+
+    def decode_base64 str
+      str.split('.').map{ |d| d.tr('-_~', '+/=').unpack('m0').first }
+    end
+
+    def new_cipher
+      OpenSSL::Cipher.new(ENV['CIPHER_ALGO'] || 'aes-128-gcm')
+    rescue OpenSSL::Cipher::CipherError
+      OpenSSL::Cipher.new('aes-128-cbc')
+    end
+
+    def auth_tag cipher
+      cipher.respond_to?(:auth_tag) && cipher.auth_tag || ''
+    end
+
+    def set_auth_tag cipher, tag
+      cipher.respond_to?(:auth_tag=) && cipher.auth_tag = tag
+    end
+
+    # MISC
+    def logger env
+      env['rack.logger'] || begin
+        require 'logger'
+        Logger.new(env['rack.errors'])
+      end
+    end
+  end
+end