duffel_api 0.0.1.pre.dev → 0.1.0

data/examples/book_with_seat.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "duffel_api"
+
+client = DuffelAPI::Client.new(
+  access_token: ENV["DUFFEL_ACCESS_TOKEN"],
+)
+
+# 365 days from now
+departure_date = (Time.now + (60 * 60 * 24 * 365)).strftime("%Y-%m-%d")
+
+offer_request = client.offer_requests.create(params: {
+  cabin_class: "economy",
+  passengers: [{
+    age: 28,
+  }],
+  slices: [{
+    # We use a non-sensical route to make sure we get speedy, reliable Duffel Airways
+    # results.
+    origin: "LGA",
+    destination: "JFK",
+    departure_date: departure_date,
+  }],
+  # This attribute is sent as a query parameter rather than in the body like the others.
+  # Worry not! The library handles this complexity for you.
+  return_offers: false,
+})
+
+puts "Created offer request: #{offer_request.id}"
+
+offers = client.offers.all(params: { offer_request_id: offer_request.id })
+
+puts "Got #{offers.count} offers"
+
+selected_offer = offers.first
+
+puts "Selected offer #{selected_offer.id} to book"
+
+priced_offer = client.offers.get(selected_offer.id,
+                                 params: { return_available_services: true })
+
+puts "The final price for offer #{priced_offer.id} is #{priced_offer.total_amount} " \
+     "#{priced_offer.total_currency}"
+
+seat_maps = client.seat_maps.list(params: { offer_id: priced_offer.id })
+
+available_seat = seat_maps.records.first.cabins.
+  first["rows"].
+  flat_map { |row| row["sections"] }.
+  flat_map { |section| section["elements"] }.
+  find do |element|
+  element["type"] == "seat" && element["available_services"].any?
+end
+
+available_seat_service = available_seat["available_services"].first
+
+puts "Adding seat #{available_seat['designator']} costing " \
+     "#{available_seat_service['total_amount']} " \
+     "#{available_seat_service['total_currency']}"
+
+total_amount = priced_offer.total_amount.to_f +
+  available_seat_service["total_amount"].to_f
+
+order = client.orders.create(params: {
+  selected_offers: [priced_offer.id],
+  services: [{
+    id: available_seat_service["id"],
+    quantity: 1,
+  }],
+  payments: [
+    {
+      type: "balance",
+      amount: total_amount,
+      currency: priced_offer.total_currency,
+    },
+  ],
+  passengers: [
+    {
+      id: priced_offer.passengers.first["id"],
+      title: "mr",
+      gender: "m",
+      given_name: "Tim",
+      family_name: "Rogers",
+      born_on: "1993-04-01",
+      phone_number: "+441290211999",
+      email: "tim@duffel.com",
+    },
+  ],
+})
+
+puts "Created order #{order.id} with booking reference #{order.booking_reference}"

data/examples/exploring_data.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "duffel_api"
+
+client = DuffelAPI::Client.new(
+  access_token: ENV["DUFFEL_ACCESS_TOKEN"],
+)
+
+puts "Loading airports..."
+
+airports = client.airports.all
+
+puts "Got #{airports.count} airports"
+
+puts "Found airport #{airports.first.name} (#{airports.first.iata_code})"
+
+airport = client.airports.get(airports.first.id)
+
+puts "Airport is located at #{airport.latitude}, #{airport.longitude}"
+
+puts "Loading aircraft..."
+
+aircraft = client.aircraft.all
+
+puts "Got #{aircraft.count} aircraft"
+
+puts "Found aircraft #{aircraft.first.name}"
+
+single_aircraft = client.aircraft.get(aircraft.first.id)
+
+puts "Aircraft's IATA code is #{single_aircraft.iata_code}"
+
+puts "Loading airlines..."
+
+airlines = client.airlines.all
+
+puts "Got #{airlines.count} airlines"
+
+puts "Found airline #{airlines.first.name}"
+
+airline = client.airlines.get(airlines.first.id)
+
+puts "Airline's IATA code is #{airline.iata_code}"

data/examples/hold_and_pay_later.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "duffel_api"
+
+client = DuffelAPI::Client.new(
+  access_token: ENV["DUFFEL_ACCESS_TOKEN"],
+)
+
+# 365 days from now
+departure_date = (Time.now + (60 * 60 * 24 * 365)).strftime("%Y-%m-%d")
+
+offer_request = client.offer_requests.create(params: {
+  cabin_class: "economy",
+  passengers: [{
+    age: 28,
+  }],
+  slices: [{
+    # We use a non-sensical route to make sure we get speedy, reliable Duffel Airways
+    # results.
+    origin: "LHR",
+    destination: "STN",
+    departure_date: departure_date,
+  }],
+  # This attribute is sent as a query parameter rather than in the body like the others.
+  # Worry not! The library handles this complexity for you.
+  return_offers: false,
+})
+
+puts "Created offer request: #{offer_request.id}"
+
+offers = client.offers.all(params: { offer_request_id: offer_request.id })
+
+puts "Got #{offers.count} offers"
+
+selected_offer = offers.first
+
+puts "Selected offer #{selected_offer.id} to book"
+
+priced_offer = client.offers.get(selected_offer.id,
+                                 params: { return_available_services: true })
+
+puts "The final price for offer #{priced_offer.id} is #{priced_offer.total_amount} " \
+     "#{priced_offer.total_currency}"
+
+order = client.orders.create(params: {
+  type: "hold",
+  selected_offers: [priced_offer.id],
+  passengers: [
+    {
+      id: priced_offer.passengers.first["id"],
+      title: "mr",
+      gender: "m",
+      given_name: "Tim",
+      family_name: "Rogers",
+      born_on: "1993-04-01",
+      phone_number: "+441290211999",
+      email: "tim@duffel.com",
+    },
+  ],
+})
+
+puts "Created hold order #{order.id} with booking reference #{order.booking_reference}"
+
+updated_order = client.orders.get(order.id)
+
+puts "Retrieved order and up-to-date price is #{updated_order.total_amount} " \
+     "#{updated_order.total_currency}"
+
+payment = client.payments.create(params: {
+  order_id: order.id,
+  payment: {
+    type: "balance",
+    amount: updated_order.total_amount,
+    currency: updated_order.total_currency,
+  },
+})
+
+puts "Paid for order #{order.id} with payment #{payment.id}"
+
+paid_order = client.orders.get(order.id)
+
+puts "After payment, order has #{paid_order.documents.length} documents"

data/examples/search_and_book.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "duffel_api"
+
+client = DuffelAPI::Client.new(
+  access_token: ENV["DUFFEL_ACCESS_TOKEN"],
+)
+
+# 365 days from now
+departure_date = (Time.now + (60 * 60 * 24 * 365)).strftime("%Y-%m-%d")
+
+offer_request = client.offer_requests.create(params: {
+  cabin_class: "economy",
+  passengers: [{
+    age: 28,
+  }],
+  slices: [{
+    # We use a non-sensical route to make sure we get speedy, reliable Duffel Airways
+    # resullts.
+    origin: "LHR",
+    destination: "STN",
+    departure_date: departure_date,
+  }],
+  # This attribute is sent as a query parameter rather than in the body like the others.
+  # Worry not! The library handles this complexity for you.
+  return_offers: false,
+})
+
+puts "Created offer request: #{offer_request.id}"
+
+offers = client.offers.all(params: { offer_request_id: offer_request.id })
+
+puts "Got #{offers.count} offers"
+
+selected_offer = offers.first
+
+puts "Selected offer #{selected_offer.id} to book"
+
+priced_offer = client.offers.get(selected_offer.id,
+                                 params: { return_available_services: true })
+
+puts "The final price for offer #{priced_offer.id} is #{priced_offer.total_amount} " \
+     "#{priced_offer.total_currency}"
+
+available_service = priced_offer.available_services.first
+
+puts "Adding an extra bag with service #{available_service['id']}, " \
+     "costing #{available_service['total_amount']} #{available_service['total_currency']}"
+
+total_amount = priced_offer.total_amount.to_f + available_service["total_amount"].to_f
+
+order = client.orders.create(params: {
+  selected_offers: [priced_offer.id],
+  services: [{
+    id: available_service["id"],
+    quantity: 1,
+  }],
+  payments: [
+    {
+      type: "balance",
+      amount: total_amount,
+      currency: priced_offer.total_currency,
+    },
+  ],
+  passengers: [
+    {
+      id: priced_offer.passengers.first["id"],
+      title: "mr",
+      gender: "m",
+      given_name: "Tim",
+      family_name: "Rogers",
+      born_on: "1993-04-01",
+      phone_number: "+441290211999",
+      email: "tim@duffel.com",
+    },
+  ],
+})
+
+puts "Created order #{order.id} with booking reference #{order.booking_reference}"
+
+order_cancellation = client.order_cancellations.create(params: {
+  order_id: order.id,
+})
+
+puts "Requested refund quote for order #{order.id} - " \
+     "#{order_cancellation.refund_amount} #{order_cancellation.refund_currency} is " \
+     "available"
+
+client.order_cancellations.confirm(order_cancellation.id)
+
+puts "Confirmed refund quote for order #{order.id}"

data/lib/duffel_api/api_response.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  # wraps a faraday response object with some accessors
+  class APIResponse
+    extend Forwardable
+
+    def initialize(response)
+      @response = response
+    end
+
+    def_delegator :@response, :headers
+    def_delegator :@response, :raw_body, :body
+    def_delegator :@response, :status_code
+    def_delegator :@response, :request_id
+  end
+end

data/lib/duffel_api/api_service.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "uri"
+
+module DuffelAPI
+  class APIService
+    def initialize(base_url, access_token, options = {})
+      @base_url = base_url
+      root_url, @path_prefix = unpack_url(base_url)
+
+      @connection = Faraday.new(root_url) do |faraday|
+        faraday.response :raise_duffel_errors
+
+        faraday.adapter(:net_http)
+      end
+
+      @headers = options[:default_headers] || {}
+      @headers["Authorization"] = "Bearer #{access_token}"
+    end
+
+    def make_request(method, path, options = {})
+      raise ArgumentError, "options must be a hash" unless options.is_a?(Hash)
+
+      options[:headers] ||= {}
+      options[:headers] = @headers.merge(options[:headers])
+      Request.new(@connection, method, @path_prefix + path, options).request
+    end
+
+    private
+
+    def unpack_url(url)
+      path = URI.parse(url).path
+      [URI.join(url).to_s, path == "/" ? "" : path]
+    end
+  end
+end

data/lib/duffel_api/client.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  class Client
+    API_VERSION = "beta"
+
+    def initialize(access_token:, base_url: "https://api.duffel.com")
+      @api_service = APIService.new(base_url, access_token, default_options)
+    end
+
+    def aircraft
+      @aircraft ||= Services::AircraftService.new(@api_service)
+    end
+
+    def airlines
+      @airlines ||= Services::AirlinesService.new(@api_service)
+    end
+
+    def airports
+      @airports ||= Services::AirportsService.new(@api_service)
+    end
+
+    def offer_passengers
+      @offer_passengers ||= Services::OfferPassengersService.new(@api_service)
+    end
+
+    def offer_requests
+      @offer_requests ||= Services::OfferRequestsService.new(@api_service)
+    end
+
+    def offers
+      @offers ||= Services::OffersService.new(@api_service)
+    end
+
+    def order_cancellations
+      @order_cancellations ||= Services::OrderCancellationsService.new(@api_service)
+    end
+
+    def order_change_offers
+      @order_change_offers ||= Services::OrderChangeOffersService.new(@api_service)
+    end
+
+    def order_change_requests
+      @order_change_requests ||= Services::OrderChangeRequestsService.new(@api_service)
+    end
+
+    def order_changes
+      @order_changes ||= Services::OrderChangesService.new(@api_service)
+    end
+
+    def orders
+      @orders ||= Services::OrdersService.new(@api_service)
+    end
+
+    def payment_intents
+      @payment_intents ||= Services::PaymentIntentsService.new(@api_service)
+    end
+
+    def payments
+      @payments ||= Services::PaymentsService.new(@api_service)
+    end
+
+    def refunds
+      @refunds ||= Services::RefundsService.new(@api_service)
+    end
+
+    def seat_maps
+      @seat_maps ||= Services::SeatMapsService.new(@api_service)
+    end
+
+    def webhooks
+      @webhooks ||= Services::WebhooksService.new(@api_service)
+    end
+
+    private
+
+    def default_options
+      {
+        default_headers: {
+          "Duffel-Version" => API_VERSION,
+          "User-Agent" => "Duffel/#{API_VERSION} duffel_api_ruby/#{DuffelAPI::VERSION}",
+          "Content-Type" => "application/json",
+        },
+      }
+    end
+  end
+end

data/lib/duffel_api/errors/airline_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Errors
+    class AirlineError < Error
+    end
+  end
+end

data/lib/duffel_api/errors/api_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Errors
+    class APIError < Error
+    end
+  end
+end

data/lib/duffel_api/errors/authentication_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Errors
+    class AuthenticationError < Error
+    end
+  end
+end

data/lib/duffel_api/errors/error.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Errors
+    class Error < StandardError
+      attr_reader :error
+
+      def initialize(error, response = nil)
+        raise ArgumentError, "Duffel errors expect a hash" unless error.is_a?(Hash)
+
+        @error = error
+        @response = response
+
+        super(error)
+      end
+
+      def documentation_url
+        @error["documentation_url"]
+      end
+
+      def title
+        @error["title"]
+      end
+
+      def message
+        @error["message"]
+      end
+
+      def to_s
+        @error["message"]
+      end
+
+      def type
+        @error["type"]
+      end
+
+      def code
+        @error["code"]
+      end
+
+      def request_id
+        @error["request_id"]
+      end
+
+      def source
+        @error["source"]
+      end
+
+      def api_response
+        APIResponse.new(@response)
+      end
+    end
+  end
+end

data/lib/duffel_api/errors/invalid_request_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Errors
+    class InvalidRequestError < Error
+    end
+  end
+end

data/lib/duffel_api/errors/invalid_state_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Errors
+    class InvalidStateError < Error
+    end
+  end
+end

data/lib/duffel_api/errors/rate_limit_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Errors
+    class RateLimitError < Error
+    end
+  end
+end

data/lib/duffel_api/errors/validation_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Errors
+    class ValidationError < Error
+    end
+  end
+end

data/lib/duffel_api/list_response.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  class ListResponse
+    attr_reader :records
+
+    def initialize(options = {})
+      @response = options.fetch(:response)
+      @resource_class = options.fetch(:resource_class)
+      @unenveloped_body = options.fetch(:unenveloped_body)
+
+      @records = @unenveloped_body.map { |item| @resource_class.new(item, @response) }
+    end
+
+    def api_response
+      @api_response ||= APIResponse.new(@response)
+    end
+
+    def before
+      @response.parsed_body["meta"]["before"]
+    end
+
+    def after
+      @response.parsed_body["meta"]["after"]
+    end
+  end
+end

data/lib/duffel_api/middlewares/raise_duffel_errors.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+module DuffelAPI
+  module Middlewares
+    class RaiseDuffelErrors < Faraday::Response::Middleware
+      UNEXPECTED_ERROR_STATUSES = (501..599).freeze
+      EXPECTED_ERROR_STATUSES = (400..500).freeze
+
+      # rubocop:disable Metrics/AbcSize
+      def on_complete(env)
+        if !json?(env) || UNEXPECTED_ERROR_STATUSES.include?(env.status)
+          response = Response.new(env.response)
+          raise DuffelAPI::Errors::Error.new(generate_error_data(env), response)
+        end
+
+        if EXPECTED_ERROR_STATUSES.include?(env.status)
+          json_body ||= JSON.parse(env.body) unless env.body.empty?
+          error = json_body["errors"].first
+          error_type = error["type"]
+
+          error_class = error_class_for_type(error_type)
+
+          response = Response.new(env.response)
+
+          raise error_class.new(error, response)
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def error_class_for_type(type)
+        {
+          airline_error: DuffelAPI::Errors::AirlineError,
+          api_error: DuffelAPI::Errors::APIError,
+          authentication_error: DuffelAPI::Errors::AuthenticationError,
+          invalid_request_error: DuffelAPI::Errors::InvalidRequestError,
+          invalid_state_error: DuffelAPI::Errors::InvalidStateError,
+          rate_limit_error: DuffelAPI::Errors::RateLimitError,
+          validation_error: DuffelAPI::Errors::ValidationError,
+        }.fetch(type.to_sym) || DuffelAPI::Errors::Error
+      end
+
+      def generate_error_data(env)
+        {
+          "message" => "Something went wrong with this request\n" \
+                       "Code: #{env.status}\n" \
+                       "Headers: #{env.response_headers}\n" \
+                       "Body: #{env.body}",
+          "code" => env.status,
+        }
+      end
+
+      def json?(env)
+        content_type = env.response_headers["Content-Type"] ||
+          env.response_headers["content-type"] || ""
+
+        content_type.include?("application/json")
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware raise_duffel_errors: DuffelAPI::
+    Middlewares::RaiseDuffelErrors

data/lib/duffel_api/paginator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  class Paginator
+    def initialize(options = {})
+      @service = options.fetch(:service)
+      @options = options.fetch(:options)
+    end
+
+    def enumerator
+      response = @service.list(@options)
+
+      Enumerator.new do |yielder|
+        loop do
+          response.records.each { |item| yielder << item }
+
+          after_cursor = response.after
+          break if after_cursor.nil?
+
+          @options[:params] ||= {}
+          @options[:params] = @options[:params].merge(after: after_cursor)
+          response = @service.list(@options)
+        end
+      end.lazy
+    end
+  end
+end