amadeus 0.1.0 → 1.0.0.beta1

data/lib/amadeus/client/request/hash.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Amadeus
+  class Request
+    # Helper methods to for the {Amadeus::Request} object to help it
+    # flatten hash keys
+    # @!visibility private
+    module Hash
+      private
+
+      # Flattens the hash keys, so page: { offset: 1 } becomes
+      # 'page[offset] => 1'
+      def flatten_keys(value, key = nil, out_hash = {})
+        case value
+        when nil then return ''
+        when ::Hash
+          value.each { |k, v| flatten_keys(v, append_key(key, k), out_hash) }
+        when Array
+          value.each { |v| flatten_keys(v, :"#{key}[]", out_hash) }
+        else
+          out_hash[key] = value
+        end
+        out_hash
+      end
+
+      # Used by .flatten_keys to add a sub key to a key
+      def append_key(root_key, key)
+        root_key.nil? ? :"#{key}" : :"#{root_key}[#{key.to_s}]"
+      end
+    end
+  end
+end

data/lib/amadeus/client/response.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'amadeus/client/response/parser'
+
+module Amadeus
+  # The response object returned for every API call.
+  class Response
+    include Parser
+
+    # The actual HTTPResponse object returned from the Net::HTTP request
+    # @return [Net::HTTPResponse]
+    attr_reader :http_response
+
+    # The actual Amadeus::Request object used to make this API call
+    # @return [Amadeus::Request]
+    attr_reader :request
+
+    # The parsed JSON received from the API, if the result was JSON
+    # @return [Hash]
+    attr_reader :result
+
+    # The data extracted from the JSON data - if the body contained JSON
+    # @return [Hash]
+    attr_reader :data
+
+    # The raw body received from the API
+    # @return [String]
+    attr_reader :body
+
+    # Wether the raw body has been parsed into JSON
+    # @return [Boolean]
+    attr_reader :parsed
+
+    # The HTTP status code for the response, if any
+    # @return [Number]
+    attr_reader :status_code
+
+    # Initialize the Response object with the
+    # HTTPResponse object to parse, the client that made the request
+    # and the original request made
+    #
+    # @param [Net:::HTTPResponse] http_response the HTTPResponse returned
+    # @param [Amadeus::Request] request the request object used to
+    #   make the API call
+    # @!visibility private
+    def initialize(http_response, request)
+      @http_response = http_response
+      @request = request
+    end
+
+    # Parses the response, using the client to log any errors
+    #
+    # @param [Amadeus::Client] client  the client used to output any errors
+    # @return [Amadeus::Response] returns itself
+    # @!visibility private
+    def parse(client)
+      parse_status_code
+      parse_data(client)
+      self
+    end
+  end
+end

data/lib/amadeus/client/response/parser.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Amadeus
+  class Response
+    # Helper methods to for the {Amadeus::Response} object to help it
+    # parse the response received from the API
+    # @!visibility private
+    module Parser
+      # Tries to parse the HTTPResponse, parsing the JSON and raising the
+      # appropriate errors
+      def detect_error(client)
+        raise_error(Amadeus::ServerError, client) if @status_code >= 500
+        raise_error(Amadeus::AuthenticationError, client) if @status_code == 401
+        raise_error(Amadeus::NotFoundError, client) if @status_code == 404
+        raise_error(Amadeus::ClientError, client) if @status_code >= 400
+        raise_error(Amadeus::ParserError, client) unless @parsed
+      end
+
+      private
+
+      # Tries to parse the received data from raw string to parsed data and into
+      # a data object
+      def parse_data(client)
+        @parsed = false
+        @result = parse_json(http_response, client)
+        @data = @result.fetch('data', nil) if @result
+      end
+
+      # Logs and raises the error
+      def raise_error(error_class, client)
+        error = error_class.new(self)
+        error.log(client)
+        raise error
+      end
+
+      # Tries to parse the JSON, if there is any
+      def parse_json(http_response, client)
+        @body = http_response.body
+        return unless json?(http_response)
+        json = JSON.parse(@body)
+        @parsed = true
+        return json
+      rescue JSON::ParserError
+        raise_error(Amadeus::ParserError, client)
+      end
+
+      def parse_status_code
+        @status_code = http_response.code
+        @status_code = @status_code.to_i if @status_code
+      end
+
+      # checks if the HTTPResponse included JSON
+      def json?(http_response)
+        json_header?(http_response) && body?(http_response)
+      end
+
+      # checks if the HTTPResponse has a non-empty body
+      def body?(http_response)
+        http_response.body && !http_response.body.empty?
+      end
+
+      # checks if the HTTPResponse has a JSON header
+      def json_header?(http_response)
+        content_type = http_response['Content-Type']
+        content_types = ['application/json', 'application/vnd.amadeus+json']
+        content_type && content_types.include?(content_type.split(';').first)
+      end
+    end
+  end
+end

data/lib/amadeus/client/validator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Amadeus
+  class Client
+    # A set of helper methods to allow the validating of
+    # arguments past into the {Amadeus::Client}
+    # @!visibility private
+    module Validator
+      private
+
+      # Uses {init_optional} to find an entry, and it that returns
+      # nil it raises an ArgumentError
+      #
+      # @param [String or Symbol] key the key to find the entry
+      # @param [Hash] options the arguments were passed to the {Amadeus::Client}
+      # @raise [ArgumentError] when no entry can be found
+      #
+      def init_required(key, options)
+        init_optional(key, options).tap do |val|
+          raise(ArgumentError, "Missing required argument: #{key}") if val.nil?
+        end
+      end
+
+      # Tries to find an option by string or symbol in the options hash and
+      # in the environment variables.When it can not find it anywhere it
+      # defaults to the provided default option.
+      #
+      # @param [String or Symbol] key the key to find the entry
+      # @param [Hash] options the arguments were passed to the {Amadeus::Client}
+      # @param [Object] default an optional default value to return
+      #
+      def init_optional(key, options, default = nil)
+        value = options[key]
+        value = options[key.to_s] if value.nil?
+        value = ENV["AMADEUS_#{key.to_s.upcase}"] if value.nil?
+        value = default if value.nil?
+        value
+      end
+
+      # Checks a list of options for unrecognized keys and warns the user.
+      # This is mainly used to provide a nice experience when users make a typo
+      # in their arguments.
+      #
+      # @param [Hash] options the arguments were passed to the {Amadeus::Client}
+      # @param [Logger] logger the logger used to send warnings to
+      # @param [Hash] recognized_options a whitelist of recognized options
+      # @return [nil]
+
+      def warn_on_unrecognized_options(options, logger, recognized_options)
+        options.each_key do |key|
+          next if recognized_options.include?(key.to_sym)
+          logger.warn('Amadeus::Client::Validator') do
+            # :nocov:
+            "Unrecognized option: #{key}"
+            # :nocov:
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/amadeus/namespaces/core.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Amadeus
+  # The namespaces that allow this API to map the paths
+  # of the API to similar calls on the SDK
+  #
+  # Access via the +Amadeus::Client+ object
+  #
+  #   amadeus = Amadeus::Client.new
+  #   amadeus.reference_data
+  #   amadeus.shopping
+  #   amadeus.travel
+  #
+  module Namespaces
+    # The namespace for the checkin links and locations APIs:
+    #
+    # @return [Amadeus::Namespaces::ReferenceData]
+    # @example Some of the further namespaces available
+    #   amadeus.reference_data.urls.checkin_links
+    #   amadeus.reference_data.locations
+    #
+    def reference_data
+      ReferenceData.new(self)
+    end
+
+    # The namespace for the shopping APIs:
+    #
+    # @return [Amadeus::Namespaces::Shopping]
+    # @example Some of the further namespaces available
+    #   amadeus.shopping.flight_destinations
+    #   amadeus.shopping.flight_offers
+    #   amadeus.shopping.flight_dates
+    #   amadeus.shopping.hotel_offers
+    #   amadeus.shopping.hotels
+    #
+    def shopping
+      Shopping.new(self)
+    end
+
+    # The namespace for the travel analytics APIs:
+    #
+    # @return [Amadeus::Namespaces::Travel]
+    # @example Some of the further namespaces available
+    #   amadeus.travel.analytics.air_traffics
+    #   amadeus.travel.analytics.fare_searches
+    #
+    def travel
+      Travel.new(self)
+    end
+  end
+end

data/lib/amadeus/namespaces/reference_data.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Amadeus
+  module Namespaces
+    # A namespaced client for the
+    # +/v2/reference_data+ endpoints
+    #
+    # Access via the +Amadeus::Client+ object
+    #
+    #   amadeus = Amadeus::Client.new
+    #   amadeus.reference_data
+    #
+    class ReferenceData < Amadeus::Client::Decorator
+      # The namespace for the Urls APIs.
+      #
+      # @return [Amadeus::Namespaces::ReferenceData::Urls]
+      # @example
+      #   amadeus.reference_data.urls.checkin_links
+      #
+      def urls
+        Amadeus::Namespaces::ReferenceData::Urls.new(client)
+      end
+
+      # The namespace for the Locations APIs:
+      #
+      # @param [Number] location_id The optional ID for the location
+      # @return [Amadeus::Namespaces::ReferenceData::Locations]
+      # @example
+      #   amadeus.reference_data.locations
+      #   amadeus.reference_data.locations.airports
+      #
+      def locations(location_id = nil)
+        if location_id
+          Amadeus::Namespaces::ReferenceData::Location.new(client, location_id)
+        else
+          Amadeus::Namespaces::ReferenceData::Locations.new(client)
+        end
+      end
+    end
+  end
+end

data/lib/amadeus/namespaces/reference_data/location.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Amadeus
+  module Namespaces
+    class ReferenceData
+      # A namespaced client for the
+      # +/v2/reference-data/locations/:location_id+ endpoints
+      #
+      # Access via the +Amadeus::Client+ object
+      #
+      #   amadeus = Amadeus::Client.new
+      #   amadeus.reference_data.locations('ALHR')
+      #
+      class Location < Amadeus::Client::Decorator
+        # the Location ID
+        attr_reader :location_id
+
+        # Initialize this namespaced client with an
+        # {Amadeus::Client} instance and an optional Location ID
+        #
+        # @param [Amadeus::Client] client
+        # @param [Number] location_id
+        #
+        def initialize(client, location_id = nil)
+          super(client)
+          @location_id = location_id
+        end
+
+        # Returns details for a specific airport
+        #
+        # @return [Amadeus::Response] a parsed response
+        # @raise [Amadeus::Base] an exception if the call failed
+        # @example Find details for London Heathrow
+        #   amadeus.reference_data.locations('ALHR').get
+        #
+        def get(params = {})
+          client.get("/v1/reference-data/locations/#{@location_id}", params)
+        end
+      end
+    end
+  end
+end

data/lib/amadeus/namespaces/reference_data/locations.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Amadeus
+  module Namespaces
+    class ReferenceData
+      # A namespaced client for the
+      # +/v2/reference-data/locations+ endpoints
+      #
+      # Access via the +Amadeus::Client+ object
+      #
+      #   amadeus = Amadeus::Client.new
+      #   amadeus.reference_data.locations
+      #
+      class Locations < Amadeus::Client::Decorator
+        # The namespace for the Airports API:
+        #
+        # @return [Amadeus::Namespaces::ReferenceData::Locations::Airports]
+        # @example
+        #   amadeus.reference_data.locations.airports
+        #
+        def airports
+          Amadeus::Namespaces::ReferenceData::Locations::Airports.new(client)
+        end
+
+        # Returns a list of airports and cities matching a given keyword.
+        #
+        # @option params [String] :keyword keyword that should represent the
+        #   start of a word in a city or airport name or code
+        # @option params [String] :subType the {Amadeus::Location} to
+        #   search for
+        # @return [Amadeus::Response] a parsed response
+        # @raise [Amadeus::Base] an exception if the call failed
+        # @example Find any location starting with 'lon'
+        #   amadeus.reference_data.locations.get(
+        #     keyword: 'lon',
+        #     subType: Amadeus::Location::ANY
+        #   )
+        #
+        def get(params = {})
+          client.get('/v1/reference-data/locations', params)
+        end
+      end
+    end
+  end
+end

data/lib/amadeus/namespaces/reference_data/locations/airports.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Amadeus
+  module Namespaces
+    class ReferenceData
+      class Locations
+        # A namespaced client for the
+        # +/v2/reference-data/locations/airports+ endpoints
+        #
+        # Access via the +Amadeus::Client+ object
+        #
+        #   amadeus = Amadeus::Client.new
+        #   amadeus.reference_data.locations.airports
+        #
+        class Airports < Amadeus::Client::Decorator
+          # Returns a list of relevant airports near to a given point.
+          #
+          # @option params [Double] :latitude latitude location to be at the
+          #   center of the search circle - required
+          # @option params [Double] :longitude longitude location to be at the
+          #   center of the search circle - required
+          # @return [Amadeus::Response] a parsed response
+          # @raise [Amadeus::Base] an exception if the call
+          #   failed
+          # @example Find the nearest airport to the 49.0000,2.55 lat/long
+          #   amadeus.reference_data.locations.airports.get(
+          #     longitude: 49.0000,
+          #     latitude: 2.55
+          #   )
+          #
+          def get(params = {})
+            client.get('/v1/reference-data/locations/airports', params)
+          end
+        end
+      end
+    end
+  end
+end