isotope11-suitcase 1.7.6

data/lib/suitcase/hotel/amenity.rb

@@ -0,0 +1,46 @@
+module Suitcase
+  class Hotel
+    class Amenity
+      attr_accessor :id, :description
+
+      BITS = { business_services: 1,
+        fitness_center: 2,
+        hot_tub: 4,
+        internet_access: 8,
+        kids_activities: 16,
+        kitchen: 32,
+        pets_allowed: 64,
+        swimming_pool: 128,
+        restaurant: 256,
+        whirlpool_bath: 1024,
+        breakfast: 2048,
+        babysitting: 4096,
+        jacuzzi: 8192,
+        parking: 16384,
+        room_service: 32768,
+        accessible_path: 65536,
+        accessible_bathroom: 131072,
+        roll_in_shower: 262144,
+        handicapped_parking: 524288,
+        in_room_accessibility: 1048576,
+        deaf_accessiblity: 2097152,
+        braille_or_signage: 4194304,
+        free_airport_shuttle: 8388608,
+        indoor_pool: 16777216,
+        outdoor_pool: 33554432,
+        extended_parking: 67108864,
+        free_parking: 134217728
+      }
+
+      def initialize(info)
+        @id, @description = info[:id], info[:description]
+      end
+
+      def self.parse_mask(bitmask)
+        return nil unless bitmask
+
+        BITS.select { |amenity, bit| (bitmask & bit) > 0 }.keys
+      end
+    end
+  end
+end

data/lib/suitcase/hotel/bed_type.rb

@@ -0,0 +1,21 @@
+module Suitcase
+  class Hotel
+    # Public: A BedType represents a bed configuration for a Room.
+    class BedType
+      # Internal: The ID of the BedType.
+      attr_accessor :id
+
+      # Internal: The description of the BedType.
+      attr_accessor :description
+
+      # Internal: Create a new BedType.
+      #
+      # info  - A Hash from the parsed API response with the following keys:
+      #         :id           - The ID of the BedType.
+      #         :description  3- The description of the BedType.
+      def initialize(info)
+        @id, @description = info[:id], info[:description]
+      end
+    end
+  end
+end

data/lib/suitcase/hotel/cache.rb

@@ -0,0 +1,52 @@
+module Suitcase
+  class Hotel
+    class Cache
+      attr_accessor :store
+
+      def initialize(store)
+        @store = store
+      end
+
+      def save_query(action, params, response)
+        %w(apiKey cid customerSessionId customerIpAddress locale
+        customerUserAgent).each do |param|
+          params.delete(param)
+        end
+        params.delete("currencyCode") unless action == :paymentInfo
+
+        string_params = keys_to_strings(params)
+
+        @store[action] ||= {}
+        @store[action] = @store[action].merge(string_params => response)
+      end
+
+      def get_query(action, params)
+        string_params = keys_to_strings(params)
+        @store[action] ? @store[action][string_params] : nil
+      end
+
+      def keys
+        @store.keys
+      end
+
+      def cached?(action, params)
+        string_params = keys_to_strings(params)
+        @store[action] && @store[action][string_params]
+      end
+
+      def undefine_query(action, params)
+        string_params = keys_to_strings(params)
+        @store[action].delete(string_params) if @store[action]
+      end
+
+      private
+
+      def keys_to_strings(hash)
+        hash.inject({}) do |memo, (k, v)| 
+          memo[k.to_s] = v
+          memo
+        end
+      end
+    end
+  end
+end

data/lib/suitcase/hotel/cancellation.rb

@@ -0,0 +1,55 @@
+module Suitcase
+  class Hotel
+    class Cancellation
+      extend Helpers
+      include Helpers
+
+      attr_accessor :itinerary_id, :email,
+                    :confirmation_number,
+                    :reason, :cancellation_number
+
+      # Accepts a hash with the itinerary_id, confirmation_number, email
+      # and optional reason code (COP ILL DEA OTH)
+      def initialize(info)
+        info.each do |k, v|
+          instance_variable_set("@" + k.to_s, v)
+        end
+      end
+
+      # Makes the call to EAN and if successful sets the
+      # cancellation_number attribute
+      def cancel_reservation!
+        params = {}
+        params["itineraryId"]        = itinerary_id
+        params["email"]              = email
+        params["confirmationNumber"] = confirmation_number
+        params["reason"]             = reason if valid_reason?
+
+        uri = Cancellation.url(
+          method: 'cancel',
+          params: params,
+          include_key: true,
+          include_cid: true,
+          secure: true
+        )
+
+        session = Patron::Session.new
+        session.timeout = 30000
+        session.base_url = "https://" + uri.host
+        res = session.post uri.request_uri, {}
+        parsed = JSON.parse res.body
+        handle_errors(parsed)
+        @cancellation_number = parsed["HotelRoomCancellationResponse"]["cancellationNumber"]
+      end
+
+      def reservation_canceled?
+        !cancellation_number.nil?
+      end
+
+      def valid_reason?
+        %w(COP ILL DEA OTH).include?(reason)
+      end
+
+    end
+  end
+end

data/lib/suitcase/hotel/ean_exception.rb

@@ -0,0 +1,35 @@
+module Suitcase
+  class Hotel
+    # Public: An Exception to be raised from all EAN API-related errors.
+    class EANException < Exception
+      # Internal: Setter for the recovery information.
+      attr_writer :recovery
+
+      # Public: Getter for the recovery information.
+      attr_reader :recovery
+
+      # Internal: Setter for the error type.
+      attr_writer :type
+
+      # Public: Getter for the error type..
+      attr_reader :type
+
+      # Internal: Create a new EAN exception.
+      #
+      # message - The String error message returned by the API.
+      # type    - The Symbol type of the error.
+      def initialize(message, type = nil)
+        @type = type
+        super(message)
+      end
+
+      # Public: Check if the error is recoverable. If it is, recovery information
+      #         is in the attribute recovery.
+      #
+      # Returns a Boolean based on whether the error is recoverable.
+      def recoverable?
+        @recovery.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/suitcase/hotel/helpers.rb

@@ -0,0 +1,210 @@
+module Suitcase
+  # Internal: Various methods for doing things that many files need to in the
+  #           library.
+  #
+  # Examples
+  #
+  #   parameterize(something: "else", another: "thing")
+  #   # => "something=else&another=thing"
+  class Hotel
+    module Helpers
+      # Internal: Defaults for the builder options to Helpers#url.
+      URL_DEFAULTS = {
+        include_key: true,
+        include_cid: true,
+        secure: false,
+        as_form: false,
+        session: Session.new
+      }
+
+      # Internal: Parameterize a Hash.
+      #
+      # hash  - The Hash to be parameterized.
+      #
+      # Examples
+      #
+      #   parameterize(something: "else", another: "thing")
+      #   # => "something=else&another=thing"
+      #
+      # Returns a parameterized String.
+      def parameterize(hash)
+        hash.map { |key, value| "#{key}=#{value}" }.join "&"
+      end
+
+      # Internal: Build an API URL.
+      #
+      # builder - A Hash with the following required keys:
+      #           :method       - The API method to be put in the URL.
+      #           :params       - The params to be put in the URL.
+      #           And the following optional ones:
+      #           :include_key  - Whether to include the API key or not.
+      #           :include_cid  - Whether to include the API cid or not.
+      #           :secure       - Whether or not for the request to be sent over
+      #                           HTTPS.
+      #           :as_form      - Whether or not to include the parameters in the
+      #                           URL.
+      #           :session      - The Session associated with the request.
+      #
+      # Examples
+      #
+      #   url(secure: true, as_form: true, method: "myMethod", params: {})
+      #   # => #<URI::HTTPS URL:https://book.api.ean.com/.../rs/hotel/v3/myMethod>
+      #
+      # Returns the URI with the builder's information.
+      def url(builder)
+        builder = URL_DEFAULTS.merge(builder)
+        builder[:session] ||= URL_DEFAULTS[:session]
+        method, params = builder[:method], builder[:params]
+        params["apiKey"] = Configuration.hotel_api_key if builder[:include_key]
+        params["cid"] = (Configuration.hotel_cid ||= 55505) if builder[:include_cid]
+        params["sig"] = generate_signature if Configuration.use_signature_auth?
+        params["minorRev"] = Configuration.ean_revision
+
+        url = main_url(builder[:secure]) + method.to_s + (builder[:as_form] ? "" : "?")
+
+        params.merge!(build_session_params(builder[:session]))
+        url += parameterize(params) unless builder[:as_form]
+        URI.parse(URI.escape(url))
+      end
+
+      # Internal: Get the root URL for the Hotels API.
+      #
+      # secure - Whether or not the URL should be HTTPS or not.
+      #
+      # Returns the URL.
+      def main_url(secure)
+        url = "http#{secure ? "s" : ""}://#{secure ? "book." : ""}"
+        url += "api.ean.com/ean-services/rs/hotel/v3/"
+        url
+      end
+
+      # Internal: Parse the JSON response at the given URL and handle errors.
+      #
+      # uri - The URI to parse the JSON from.
+      #
+      # Returns the parsed JSON.
+      def parse_response(uri)
+        response = Net::HTTP.get_response(uri)
+
+        if response.code.to_i == 403
+          if response.body.include?("Forbidden")
+            e = EANException.new("You have not been granted permission to access the requested method or object.")
+            e.type = :forbidden
+          elsif response.body.include?("Not Authorized")
+            e = EANException.new("The API key associated with your request was not recognized, or the digital signature was incorrect.")
+            e.type = :not_authorized
+          elsif response.body.include?("Developer Inactive")
+            e = EANException.new("The API key you are using to access the API has not been approved, is not correct, or has been disabled. If using SIG Authentication, your digital signature is incorrect and does not match the one generated when receiving your request.")
+            e.type = :developer_inactive
+          elsif response.body.include?("Queries Per Second Limit")
+            e = EANException.new("The API key you are using has attempted to access the API too many times in one second.")
+            e.type = :query_limit
+          elsif response.body.include?("Account Over Rate Limit")
+            e = EANException.new("The API key you are using has attempted to access the API too many times in the rate limiting period.")
+            e.type = :rate_limit
+          elsif response.body.include?("Rate Limit Exceeded")
+            e = EANException.new("The service you have requested is over capacity.")
+            e.type = :over_capacity
+          elsif response.body.include?("Authentication Failure")
+            e = EANException.new("The combination of authentication checks failed.")
+            e.type = :authentication_failure
+          else
+            e = EANException.new("An unknown error occured: #{response.body}.")
+            e.type = :unknown
+          end
+
+          raise e
+        end
+
+        JSON.parse(Net::HTTP.get_response(uri).body)
+      end
+
+      # Internal: Raise the errors returned from the response.
+      #
+      # info - The parsed JSON to get the errors from.
+      #
+      # Returns nothing.
+      def handle_errors(info)
+        key = info.keys.first
+        if info[key] && info[key]["EanWsError"]
+          message = info[key]["EanWsError"]["presentationMessage"]
+          exception = EANException.new(message)
+          if message =~ /Multiple locations/ && (info = info[key]["LocationInfos"])
+            exception.type = :multiple_locations
+            exception.recovery = {
+              alternate_locations: info["LocationInfo"].map do |info|
+              Location.new(
+                destination_id: info["destinationId"],
+                type: info["type"],
+                city: info["city"],
+                province: info["stateProvinceCode"]
+              )
+              end
+            }
+          elsif message =~ /Data in this request could not be validated/
+            exception.type = :invalid_data
+          end
+
+          raise exception
+        end
+      end
+
+      # Internal: Get the base URL based on a Hash of info.
+      #
+      # info  - A Hash with only one required key:
+      #         :booking - Whether or not it is a booking request.
+      #
+      # Returns the base URL.
+      def base_url(info)
+        main_url(info[:booking])
+      end
+
+      # Internal: Build a Hash of params from a Session.
+      #
+      # session - The Session to generate params from.
+      #
+      # Returns the Hash of params.
+      def build_session_params(session)
+        session_info = {}
+        session_info["customerSessionId"] = session.id if session.id
+        session_info["customerIpAddress"] = session.ip_address if session.ip_address
+        session_info["locale"] = session.locale if session.locale
+        session_info["currencyCode"] = session.currency_code if session.currency_code
+        session_info["customerUserAgent"] = session.user_agent if session.user_agent
+        session_info
+      end
+
+      # Internal: Update the Session's ID with the parsed JSON.
+      #
+      # parsed  - The parsed JSON to fetch the ID from.
+      # session - The Session to update.
+      #
+      # Returns nothing.
+      def update_session(parsed, session)
+        session ||= Session.new
+        session.id = parsed[parsed.keys.first]["customerSessionId"] if parsed[parsed.keys.first]
+      end
+
+      # Internal: Generate a digital signature to authenticate with.
+      #
+      # Returns the generated signature.
+      def generate_signature
+        Digest::MD5.hexdigest(Configuration.hotel_api_key + 
+                              Configuration.hotel_shared_secret + 
+                              Time.now.to_i.to_s)
+      end
+
+      # Internal: Build a rooms parameter given an array of hashes
+      #
+      # Returns the rooms parameters hash
+      def parameterize_rooms(rooms)
+        params = {}
+        rooms.each_with_index do |room, n|
+          params["room#{n+1}"] = room[:adults].to_s
+          params["room#{n+1}"] += "," + room[:children_ages].join(",") if room[:children_ages]
+        end
+        params
+      end
+    end
+  end
+end

data/lib/suitcase/hotel/image.rb

@@ -0,0 +1,19 @@
+module Suitcase
+  class Image
+    attr_accessor :id, :url, :caption, :width, :height, :thumbnail_url, :name
+
+    def initialize(data)
+      @id = data["hotelImageId"]
+      @name = data["name"]
+      @caption = data["caption"]
+      @url = data["url"]
+      @thumbnail_url = data["thumbnailURL"]
+      @width = data["width"]
+      @height = data["height"]
+    end
+
+    def size
+      width.to_s + "x" + height.to_s
+    end
+  end
+end