amadeus 0.1.0 → 1.0.0.beta1

data/lib/amadeus/client/access_token.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'net/https'
+
+module Amadeus
+  class Client
+    # A helper library to create and maintain the
+    # OAuth2 AccessTokens between requests
+    # @!visibility private
+    class AccessToken < Amadeus::Client::Decorator
+      # The number of seconds before the token expires, when
+      # we will already try to refresh it
+      TOKEN_BUFFER = 10
+
+      # The bearer token that can be used directly in API request headers
+      #
+      # @example A full token
+      #     Bearer 12345678
+      def bearer_token
+        "Bearer #{token}"
+      end
+
+      private
+
+      # Returns the access token if it is still valid,
+      # or refreshes it if it is not (or about to expire)
+      def token
+        return @access_token if @access_token && !needs_refresh?
+        update_access_token
+        @access_token
+      end
+
+      # Checks if the token needs a refesh by checking if the token
+      # is nil or (about to) expire(d)
+      def needs_refresh?
+        @access_token.nil? ||
+          (Time.now + TOKEN_BUFFER) > @expires_at
+      end
+
+      # Fetches a new access token and stores it and its expiry date
+      def update_access_token
+        response = fetch_access_token
+        store_access_token(response.result)
+      end
+
+      # Fetches a new access token
+      def fetch_access_token
+        client.unauthenticated_request(:POST, '/v1/security/oauth2/token',
+                                       grant_type: 'client_credentials',
+                                       client_id: client.client_id,
+                                       client_secret: client.client_secret)
+      end
+
+      # Store an access token and calculates the expiry date
+      def store_access_token(data)
+        @access_token = data['access_token']
+        @expires_at = Time.now + data['expires_in']
+      end
+    end
+  end
+end

data/lib/amadeus/client/decorator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Amadeus
+  class Client
+    # A superclass that allows any namespaced superclass
+    # to easily wrap the client object
+    #
+    # @abstract
+    # @!visibility private
+    class Decorator
+      # The API client
+      # @return [Amadeus::Client]
+      attr_reader :client
+
+      # Initialize the namespaced client with an
+      # {Amadeus::Client} instance
+      #
+      # @param [Amadeus::Client] client
+      def initialize(client)
+        if client.nil?
+          raise(ArgumentError, 'Missing required parameter: Amadeus::Client')
+        end
+        @client = client
+      end
+    end
+  end
+end

data/lib/amadeus/client/errors.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Amadeus
+  # A custom generic Amadeus error.
+  #
+  # @abstract
+  class ResponseError < RuntimeError
+    # The response object containing the raw HTTP response and the request
+    # used to make the API call.
+    #
+    # @return [Amadeus::Response]
+    attr_reader :response
+
+    # A unique code for this type of error. Options include
+    # +NetworkError+, +ParserError+, +ServerError+,
+    # +AuthenticationError+, +NotFoundError+ and +UnknownError+.
+    #
+    # @return [String]
+    attr_reader :code
+
+    # The content of the response that describes the error
+    #
+    # @return [Hash]
+    attr_reader :description
+
+    # Initializes an error by storing the {Amadeus::Response} object
+    # that raised this error. The continues to determien the custom
+    # error message
+    #
+    # @param [Amadeus::Response] response
+    # @!visibility private
+    def initialize(response)
+      @response = response
+      @description = determine_description
+      super(@description)
+      @code = determine_code
+    end
+
+    # PROTECTED
+
+    def log(client)
+      # :nocov:
+      return unless client.log_level == 'warn'
+      client.logger.warn("Amadeus #{@code}") do
+        JSON.pretty_generate(@description) if @description
+      end
+      # :nocov:
+    end
+
+    private
+
+    def determine_description
+      return nil unless response && response.parsed
+      result = response.result
+      return result['errors'] if result['errors']
+      return result if result['error_description']
+    end
+
+    def determine_code
+      self.class.to_s.split('::').last
+    end
+  end
+
+  # This error occurs when there is some kind of error in the network
+  class NetworkError < Amadeus::ResponseError; end
+  # This error occurs when the response type was JSOn but could not be parsed
+  class ParserError < Amadeus::ResponseError; end
+  # This error occurs when there is an error on the server
+  class ServerError < Amadeus::ResponseError; end
+  # This error occurs when the client did not provide the right parameters
+  class ClientError < Amadeus::ResponseError; end
+  # This error occurs when the client did not provide the right credentials
+  class AuthenticationError < Amadeus::ResponseError; end
+  # This error occurs when the path could not be found
+  class NotFoundError < Amadeus::ResponseError; end
+end

data/lib/amadeus/client/http.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'net/https'
+
+require 'amadeus/client/request'
+
+module Amadeus
+  class Client
+    # A helper module for making generic API calls. It is used by
+    # every namespaced API method.
+    module HTTP
+      # A helper module for making generic GET requests calls. It is used by
+      # every namespaced API GET method.
+      #
+      #   amadeus.reference_data.urls.checkin_links.get(airline: '1X')
+      #
+      # It can be used to make any generic API call that is automatically
+      # authenticated using your API credentials:
+      #
+      #   amadeus.get('/v2/reference-data/urls/checkin-links', {
+      #     airline: '1X'
+      #   })
+      # @param [String] path the full path for the API call
+      # @param [Hash] params the optional GET params to pass to the API
+      #
+      def get(path, params = {})
+        request(:GET, path, params)
+      end
+
+      # A helper module for making generic POST requests calls. It is used by
+      # every namespaced API POST method.
+      #
+      #   amadeus.foo.bar.post(some: 'data')
+      #
+      # It can be used to make any generic API call that is automatically
+      # authenticated using your API credentials:
+      #
+      #   amadeus.post('/v2/foo/bar', { some: 'data' })
+      #
+      # To make an unauthenticated API call, make sure to pass in an explicit
+      # nil for the access token:
+      #
+      #   amadeus.post('/v2/foo/bar', { some: 'data' }, nil)
+      #
+      # @param [String] path the full path for the API call
+      # @param [Hash] params the optional POST params to pass to the API
+      #
+      def post(path, params = {})
+        request(:POST, path, params)
+      end
+
+      # A more generic helper for making authenticated API calls
+      #
+      # @param [Symbol] verb the HTTP verb to use
+      # @param [String] path the full path for the API call
+      # @param [Hash] params the optional POST params to pass to the API
+      # @!visibility private
+      #
+      def request(verb, path, params = {})
+        unauthenticated_request(verb, path, params, access_token.bearer_token)
+      end
+
+      # Builds the URI, the request object, and makes the actual API calls.
+      #
+      # Used by the AccessToken to fetch a new Bearer Token
+      #
+      # Passes the response to a Amadeus::Response object for further
+      # parsing.
+      #
+      # @param [Symbol] verb the HTTP verb to use
+      # @param [String] path the full path for the API call
+      # @param [Hash] params the optional POST params to pass to the API
+      # @param [String] bearer_token the optional OAuth2 bearer token
+      #
+      # @!visibility private
+      def unauthenticated_request(verb, path, params, bearer_token = nil)
+        request = build_request(verb, path, params, bearer_token)
+        log(request)
+        execute(request)
+      end
+
+      private
+
+      # Builds a HTTP request object that contains all the information about
+      # this request
+      def build_request(verb, path, params, bearer_token)
+        Amadeus::Request.new(
+          host: @host, verb: verb, path: path, params: params,
+          bearer_token: bearer_token, client_version: Amadeus::VERSION,
+          language_version: RUBY_VERSION, app_id: @custom_app_id,
+          app_version: @custom_app_version, ssl: @ssl, port: @port
+        )
+      end
+
+      # Executes the request and wraps it in a Response
+      def execute(request)
+        http_response = fetch(request)
+        response = Amadeus::Response.new(http_response, request).parse(self)
+        log(response)
+        response.detect_error(self)
+        response
+      end
+
+      # Actually make the HTTP call, making sure to catch it in case of an error
+      def fetch(request)
+        @http.start(
+          request.host, request.port, use_ssl: request.ssl
+        ) do |http|
+          http.request(request.http_request)
+        end
+      rescue StandardError
+        error = Amadeus::NetworkError.new(nil)
+        error.log(self)
+        raise error
+      end
+
+      # A memoized AccessToken object, so we don't keep reauthenticating
+      def access_token
+        @access_token ||= AccessToken.new(self)
+      end
+
+      # Log any object
+      def log(object)
+        # :nocov:
+        return unless @log_level == 'debug'
+        logger.debug(object.class.name.to_s) do
+          JSON.pretty_generate(
+            ::Hash[object.instance_variables.map do |ivar|
+              [ivar, object.instance_variable_get(ivar)]
+            end]
+          )
+        end
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/amadeus/client/location.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Amadeus
+  # A list of location types, as used in searching for locations
+  module Location
+    # Airport
+    AIRPORT = 'AIRPORT'.freeze
+    # City
+    CITY = 'CITY'.freeze
+    # Any
+    ANY = [AIRPORT, CITY].join(',')
+  end
+end

data/lib/amadeus/client/pagination.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Amadeus
+  class Client
+    # Helper methods to for the {Amadeus::Response} object to help it
+    # paginate to next, previous, and first/last pages
+    module Pagination
+      # Finds the next page, if there is any, and otherwise
+      # returns nil
+      #
+      # @param [Amadeus::Response] response the response to fetch the next
+      #   page for
+      # @return [Amadeus::Response]
+      #
+      # @example Fetch the next page
+      #   page1 = amadeus.reference_data.locations.get(
+      #     keyword: 'lon',
+      #     subType: Amadeus::Location::ANY
+      #   )
+      #   page2 = amadeus.next(page1)
+      #
+      def next(response)
+        page(:next, response)
+      end
+
+      # Finds the previous page, if there is any, and otherwise
+      # returns nil
+      #
+      # @param [Amadeus::Response] response the response to fetch the previous
+      #   page for
+      # @return [Amadeus::Response]
+      #
+      # @example Fetch the previous page
+      #   page2 = amadeus.reference_data.locations.get(
+      #     keyword: 'lon',
+      #     subType: Amadeus::Location::ANY,
+      #     page: { offset: 2 }
+      #   )
+      #   page1 = amadeus.previous(page1)
+      #
+      def previous(response)
+        page(:previous, response)
+      end
+
+      # Finds the last page, if there is any, and otherwise
+      # returns nil
+      #
+      # @param [Amadeus::Response] response the response to fetch the last page
+      #   for
+      # @return [Amadeus::Response]
+      #
+      # @example Fetch the last page
+      #   page1 = amadeus.reference_data.locations.get(
+      #     keyword: 'lon',
+      #     subType: Amadeus::Location::ANY
+      #   )
+      #   last_page = amadeus.last(page1)
+      #
+      def last(response)
+        page(:last, response)
+      end
+
+      # Finds the first page, if there is any, and otherwise
+      # returns nil
+      #
+      # @param [Amadeus::Response] response the response to fetch the first page
+      #   for
+      # @return [Amadeus::Response]
+      #
+      # @example Fetch the first page
+      #   page10 = amadeus.reference_data.locations.get(
+      #     keyword: 'lon',
+      #     subType: Amadeus::Location::ANY,
+      #     page: { offset: 10 }
+      #   )
+      #   page1 = amadeus.first(page1)
+      #
+      def first(response)
+        page(:first, response)
+      end
+
+      private
+
+      # Determine the page number for the given page name
+      def page_number_for(name, response)
+        response.result['meta']['links'][name.to_s].split('=').last.to_i
+      rescue NoMethodError
+        nil
+      end
+
+      # Make a new API call for the same request, but with a new
+      # page number
+      def page(name, response)
+        page_number = page_number_for(name, response)
+        return nil unless page_number
+        params = response.request.params.clone
+        params['page'] ||= {}
+        params['page']['offset'] = page_number
+        request(response.request.verb, response.request.path, params)
+      end
+    end
+  end
+end

data/lib/amadeus/client/request.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'amadeus/client/request/hash'
+
+module Amadeus
+  # A Request object containing all the compiled information about this request.
+  class Request
+    include Amadeus::Request::Hash
+
+    # The host used for this API call
+    # @return [String]
+    attr_reader :host
+    # The port for this API call. Standard set to 443.
+    # @return [Number]
+    attr_reader :port
+    # Wether to use SSL for a call, defaults to true
+    # @return [Boolean]
+    attr_reader :ssl
+    # The scheme used to make the API call
+    # @return [String]
+    attr_reader :scheme
+    # The GET/POST params for the API call
+    # @return [Hash]
+    attr_reader :params
+    # The path of the API to be called
+    # @return [String]
+    attr_reader :path
+    # The verb used to make an API call (:GET or :POST)
+    # @return [Symbol]
+    attr_reader :verb
+    # The bearer token (if any) that is used for authentication
+    # @return [String]
+    attr_reader :bearer_token
+    # The headers used for the API call
+    # @return [Hash]
+    attr_reader :headers
+    # The library version used for this request
+    # @return [String]
+    attr_reader :client_version
+    # The Ruby language version used for this request
+    # @return [String]
+    attr_reader :language_version
+    # The custom app ID passed in for this request
+    # @return [String]
+    attr_reader :app_id
+    # The custom app version used for this request
+    # @return [String]
+    attr_reader :app_version
+
+    # A Request object containing all the compiled information about
+    # this request.
+    #
+    # @return [Amadeus::Request]
+    # @!visibility private
+    def initialize(options)
+      initialize_options(options)
+      initialize_headers
+      http_request
+    end
+
+    # Builds the request object
+    def http_request
+      @http_request ||= begin
+        request = request_for_verb
+        add_post_data(request)
+        add_bearer_token(request)
+        add_headers(request)
+        request
+      end
+    end
+
+    private
+
+    def initialize_options(options)
+      initialize_basic_call(options)
+      initialize_extras(options)
+    end
+
+    def initialize_basic_call(options)
+      @host             = options[:host]
+      @port             = options[:port]
+      @ssl              = options[:ssl]
+      @scheme           = @ssl ? 'https' : 'http'
+      @verb             = options[:verb]
+      @path             = options[:path]
+      @params           = options[:params]
+      @bearer_token     = options[:bearer_token]
+    end
+
+    def initialize_extras(options)
+      @client_version   = options[:client_version]
+      @language_version = options[:language_version]
+      @app_id           = options[:app_id]
+      @app_version      = options[:app_version]
+    end
+
+    def initialize_headers
+      @headers = {
+        'User-Agent' => build_user_agent,
+        'Accept' => 'application/json'
+      }
+    end
+
+    def request_for_verb
+      method = @verb == :GET ? Net::HTTP::Get : Net::HTTP::Post
+      method.new(uri)
+    end
+
+    def add_post_data(request)
+      return unless @verb == :POST
+      @headers['Content-Type'] = 'application/x-www-form-urlencoded'
+      request.form_data = @params
+    end
+
+    def add_bearer_token(_request)
+      return if @bearer_token.nil?
+      @headers['Authorization'] = @bearer_token
+    end
+
+    def add_headers(request)
+      @headers.each do |key, value|
+        request[key] = value
+      end
+    end
+
+    def build_user_agent
+      user_agent = "amadeus-ruby/#{@client_version} ruby/#{@language_version}"
+      return user_agent unless @app_id
+      user_agent + " #{@app_id}/#{@app_version}"
+    end
+
+    def uri
+      url = "#{@scheme}://#{@host}#{@path}"
+      url += ":#{@port}" unless port_matches_scheme
+      uri = URI(url)
+      params = flatten_keys(@params)
+      uri.query = URI.encode_www_form(params) if @verb == :GET
+      uri
+    end
+
+    def port_matches_scheme
+      (@ssl && @port == 443) || (!@ssl && @port == 80)
+    end
+  end
+end