duffel_api 0.0.1.pre.dev → 0.1.0

data/lib/duffel_api/resources/webhook.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Resources
+    class Webhook < BaseResource
+      attr_reader :active
+      attr_reader :created_at
+      attr_reader :events
+      attr_reader :id
+      attr_reader :live_mode
+      attr_reader :secret
+      attr_reader :updated_at
+      attr_reader :url
+
+      def initialize(object, response = nil)
+        @object = object
+
+        @active = object["active"]
+        @created_at = object["created_at"]
+        @events = object["events"]
+        @id = object["id"]
+        @live_mode = object["live_mode"]
+        @secret = object["secret"]
+        @updated_at = object["updated_at"]
+        @url = object["url"]
+
+        super(object, response)
+      end
+    end
+  end
+end

data/lib/duffel_api/response.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  class Response
+    extend Forwardable
+
+    def_delegator :@response, :headers
+    def_delegator :@response, :status, :status_code
+
+    def initialize(response)
+      @response = response
+    end
+
+    def raw_body
+      @response.body
+    end
+
+    # Return the body of parsed JSON body of the API response
+    def parsed_body
+      JSON.parse(raw_body) unless raw_body.empty?
+    end
+
+    # Returns the meta hash of the response
+    def meta
+      return {} if parsed_body.nil?
+
+      parsed_body.fetch("meta", {})
+    rescue JSON::ParserError
+      {}
+    end
+
+    # Returns the request ID from the response headers
+    def request_id
+      normalised_headers["x-request-id"]
+    end
+
+    private
+
+    def normalised_headers
+      headers.transform_keys(&:downcase)
+    end
+
+    def json?; end
+  end
+end

data/lib/duffel_api/services/aircraft_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class AircraftService < BaseService
+      def list(options = {})
+        path = "/air/aircraft"
+
+        response = make_request(:get, path, options)
+
+        ListResponse.new(
+          response: response,
+          unenveloped_body: unenvelope_body(response.parsed_body),
+          resource_class: Resources::Aircraft,
+        )
+      end
+
+      def all(options = {})
+        DuffelAPI::Paginator.new(
+          service: self,
+          options: options,
+        ).enumerator
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/air/aircraft/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::Aircraft.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/airlines_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class AirlinesService < BaseService
+      def list(options = {})
+        path = "/air/airlines"
+
+        response = make_request(:get, path, options)
+
+        ListResponse.new(
+          response: response,
+          unenveloped_body: unenvelope_body(response.parsed_body),
+          resource_class: Resources::Airline,
+        )
+      end
+
+      def all(options = {})
+        DuffelAPI::Paginator.new(
+          service: self,
+          options: options,
+        ).enumerator
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/air/airlines/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::Airline.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/airports_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class AirportsService < BaseService
+      def list(options = {})
+        path = "/air/airports"
+
+        response = make_request(:get, path, options)
+
+        ListResponse.new(
+          response: response,
+          unenveloped_body: unenvelope_body(response.parsed_body),
+          resource_class: Resources::Airport,
+        )
+      end
+
+      def all(options = {})
+        DuffelAPI::Paginator.new(
+          service: self,
+          options: options,
+        ).enumerator
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/air/airports/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::Airport.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/base_service.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module DuffelAPI
+  module Services
+    class BaseService
+      def initialize(api_service)
+        @api_service = api_service
+      end
+
+      def make_request(method, path, options = {})
+        @api_service.make_request(method, path, options)
+      end
+
+      private
+
+      def substitute_url_pattern(url, param_map)
+        param_map.reduce(url) do |new_url, (param, value)|
+          new_url.gsub(":#{param}", CGI.escape(value))
+        end
+      end
+
+      def unenvelope_body(parsed_body)
+        parsed_body["data"]
+      end
+    end
+  end
+end

data/lib/duffel_api/services/offer_passengers_service.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class OfferPassengersService < BaseService
+      def update(offer_id, passenger_id, options = {})
+        path = substitute_url_pattern(
+          "/air/offers/:offer_id/passengers/:passenger_id",
+          "offer_id" => offer_id,
+          "passenger_id" => passenger_id,
+        )
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:patch, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::OfferPassenger.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/offer_requests_service.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class OfferRequestsService < BaseService
+      def create(options = {})
+        path = "/air/offer_requests"
+
+        params = options.delete(:params) || {}
+
+        # The "Create offer request" API expects a JSON body and can also accept the
+        # `return_offers` query parameter. No other endpoints in the Duffel API allow
+        # both. To avoid making the client library interface confusing, we get the client
+        # to pass this value in along with the body params, and we know to move it into
+        # the querystring.
+        return_offers = params.delete(:return_offers)
+
+        unless return_offers.nil?
+          options[:query_params] = { return_offers: return_offers }
+        end
+
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::OfferRequest.new(unenvelope_body(response.parsed_body), response)
+      end
+
+      def list(options = {})
+        path = "/air/offer_requests"
+
+        response = make_request(:get, path, options)
+
+        ListResponse.new(
+          response: response,
+          unenveloped_body: unenvelope_body(response.parsed_body),
+          resource_class: Resources::OfferRequest,
+        )
+      end
+
+      def all(options = {})
+        Paginator.new(
+          service: self,
+          options: options,
+        ).enumerator
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/air/offer_requests/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::OfferRequest.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/offers_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class OffersService < BaseService
+      def list(options = {})
+        path = "/air/offers"
+
+        response = make_request(:get, path, options)
+
+        ListResponse.new(
+          response: response,
+          unenveloped_body: unenvelope_body(response.parsed_body),
+          resource_class: Resources::Offer,
+        )
+      end
+
+      def all(options = {})
+        Paginator.new(
+          service: self,
+          options: options,
+        ).enumerator
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/air/offers/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::Offer.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/order_cancellations_service.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class OrderCancellationsService < BaseService
+      def create(options = {})
+        path = "/air/order_cancellations"
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::OrderCancellation.new(unenvelope_body(response.parsed_body), response)
+      end
+
+      def confirm(id, options = {})
+        path = substitute_url_pattern("/air/order_cancellations/:id/actions/confirm",
+                                      "id" => id)
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::OrderCancellation.new(unenvelope_body(response.parsed_body), response)
+      end
+
+      def list(options = {})
+        path = "/air/order_cancellations"
+
+        response = make_request(:get, path, options)
+
+        ListResponse.new(
+          response: response,
+          unenveloped_body: unenvelope_body(response.parsed_body),
+          resource_class: Resources::OrderCancellation,
+        )
+      end
+
+      def all(options = {})
+        Paginator.new(
+          service: self,
+          options: options,
+        ).enumerator
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/air/order_cancellations/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::OrderCancellation.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/order_change_offers_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class OrderChangeOffersService < BaseService
+      def list(options = {})
+        path = "/air/order_change_offers"
+
+        response = make_request(:get, path, options)
+
+        ListResponse.new(
+          response: response,
+          unenveloped_body: unenvelope_body(response.parsed_body),
+          resource_class: Resources::OrderChangeOffer,
+        )
+      end
+
+      def all(options = {})
+        Paginator.new(
+          service: self,
+          options: options,
+        ).enumerator
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/air/order_change_offers/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::OrderChangeOffer.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/order_change_requests_service.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class OrderChangeRequestsService < BaseService
+      def create(options = {})
+        path = "/air/order_change_requests"
+
+        params = options.delete(:params) || {}
+
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::OrderChangeRequest.new(unenvelope_body(response.parsed_body), response)
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/air/order_change_requests/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::OrderChangeRequest.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/order_changes_service.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class OrderChangesService < BaseService
+      def create(options = {})
+        path = "/air/order_changes"
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::OrderChange.new(unenvelope_body(response.parsed_body), response)
+      end
+
+      def confirm(id, options = {})
+        path = substitute_url_pattern("/air/order_changes/:id/actions/confirm",
+                                      "id" => id)
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::OrderChange.new(unenvelope_body(response.parsed_body), response)
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/air/order_changes/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::OrderChange.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/orders_service.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class OrdersService < BaseService
+      def create(options = {})
+        path = "/air/orders"
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::Order.new(unenvelope_body(response.parsed_body), response)
+      end
+
+      def update(id, options = {})
+        path = substitute_url_pattern("/air/orders/:id", "id" => id)
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:patch, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::Order.new(unenvelope_body(response.parsed_body), response)
+      end
+
+      def list(options = {})
+        path = "/air/orders"
+
+        response = make_request(:get, path, options)
+
+        ListResponse.new(
+          response: response,
+          unenveloped_body: unenvelope_body(response.parsed_body),
+          resource_class: Resources::Order,
+        )
+      end
+
+      def all(options = {})
+        Paginator.new(
+          service: self,
+          options: options,
+        ).enumerator
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/air/orders/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::Order.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end

data/lib/duffel_api/services/payment_intents_service.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module DuffelAPI
+  module Services
+    class PaymentIntentsService < BaseService
+      def create(options = {})
+        path = "/payments/payment_intents"
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::PaymentIntent.new(unenvelope_body(response.parsed_body), response)
+      end
+
+      def confirm(id, options = {})
+        path = substitute_url_pattern("/payments/payment_intents/:id/actions/confirm",
+                                      "id" => id)
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]["data"] = params
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:raw_body)
+        end
+
+        return if response.raw_body.nil?
+
+        Resources::PaymentIntent.new(unenvelope_body(response.parsed_body), response)
+      end
+
+      def get(id, options = {})
+        path = substitute_url_pattern("/payments/payment_intents/:id", "id" => id)
+
+        response = make_request(:get, path, options)
+
+        return if response.raw_body.nil?
+
+        Resources::PaymentIntent.new(unenvelope_body(response.parsed_body), response)
+      end
+    end
+  end
+end