Finalize character endpoint

Two new parameter have been added to the character lookup: all_data
and poll. The all_data parameter will toggle between the standard lookup
and a lookup with all of the data flags. The poll parameter will
continuously poll the API until the character has been cached. A new
type of request has been created to handle this continuous polling. It
also handles the various errors states that may be returned and throws a
custom exception for each state. Adds the character update and delete
endpoints.

Author: mattantonelli

lib/xivapi.rb

@@ -1,5 +1,6 @@
 require 'xivapi/version'
 
+require 'xivapi/exceptions'
 require 'xivapi/http'
 require 'xivapi/page'
 require 'xivapi/paginator'

lib/xivapi/exceptions.rb

@@ -0,0 +1,37 @@
+module XIVAPI
+  class RequestError < StandardError
+    def initialize(response)
+      if response.headers[:content_type] == 'application/problem+json'
+        message = JSON.parse(response)['Message']
+      else
+        message = 'Error contacting the API'
+      end
+
+      super(message)
+    end
+  end
+
+  class ContentNotAvailable < StandardError
+    def initialize
+      super('Content is not currently available on XIVAPI')
+    end
+  end
+
+  class ContentNotFound < StandardError
+    def initialize
+      super('Content does not exist on the Lodestone.')
+    end
+  end
+
+  class ContentBlacklisted < StandardError
+    def initialize
+      super('Content has been blacklisted.')
+    end
+  end
+
+  class ContentPrivate < StandardError
+    def initialize
+      super('Content is private.')
+    end
+  end
+end

lib/xivapi/http.rb

@@ -11,11 +11,35 @@ def request(client, endpoint, params = {})
         response = RestClient.get(url, params: query_params)
         body = JSON.parse(response.body)
         objectify(body)
+      rescue RestClient::ExceptionWithResponse => e
+        raise XIVAPI::RequestError.new(e.response)
       rescue RestClient::Exception => e
-        raise e.response
+        raise e
       end
     end
 
+    def request_cached(client, endpoint, key, params = {}, poll = false)
+      response = request(client, endpoint, params)
+
+      case(response.info[key].state)
+      when 0
+        raise XIVAPI::ContentNotAvailable
+      when 1
+        if poll
+          sleep(client.poll_rate)
+          response = request_cached(client, endpoint, key, params, poll)
+        end
+      when 3
+        raise XIVAPI::ContentNotFound
+      when 4
+        raise XIVAPI::ContentBlacklisted
+      when 5
+        raise XIVAPI::ContentPrivate
+      end
+
+      response
+    end
+
     private
     def request_url(endpoint)
       "#{API_BASE}/#{endpoint}"

lib/xivapi/request.rb

@@ -2,6 +2,7 @@ module XIVAPI::Request
   include XIVAPI::HTTP
 
   LODESTONE_LIMIT = 50.freeze
+  ALL_CHARACTER_DATA = 'AC,FR,FC,FCM,PVP'.freeze
 
   def search(indexes: [], string: '', string_column: 'Name_en', string_algo: 'wildcard_plus',
              sort_field: nil, sort_order: nil, limit: 100, filters: [], columns: [])
@@ -10,17 +11,26 @@ def search(indexes: [], string: '', string_column: 'Name_en', string_algo: 'wild
     XIVAPI::Paginator.new(self, params, 'search', limit)
   end
 
-  def character(id: nil, data: [], columns: [])
-    params = { data: [*data].join(','), columns: [*columns].join(',') }
-    request(self, "character/#{id}", params)
+  def character(id: nil, all_data: false, poll: false, columns: [])
+    params = { data: all_data ? ALL_CHARACTER_DATA : nil, columns: [*columns].join(',') }
+    request_cached(self, "character/#{id}", :character, params, poll)
   end
 
   def character_search(name: nil, server: nil)
     params = { name: name, server: server&.capitalize }
     XIVAPI::Paginator.new(self, params, 'character/search', LODESTONE_LIMIT)
   end
 
-  def character_verified?(id)
+  def character_delete(id: nil, duplicate_id: nil)
+    params = { duplicate: duplicate_id }
+    !!request(self, "character/#{id}/delete", params)
+  end
+
+  def character_update(id: nil)
+    request(self, "character/#{id}/update") == 1
+  end
+
+  def character_verified?(id: nil)
     request(self, "character/#{id}/verification").verification_token_pass
   end