hotel_beds 0.2.1 → 0.3.0

data/lib/hotel_beds/hotel_search/parser/errors.rb

@@ -0,0 +1,49 @@
+require "active_model/errors"
+
+module HotelBeds
+  module HotelSearch
+    module Parser
+      class Errors
+        def self.call(*args, &block)
+          new(*args, &block).call
+        end
+
+        attr_accessor :response, :body
+        private :response, :body
+
+        def initialize(response, body)
+          self.response = response
+          self.body = body
+          freeze
+        end
+
+        def call
+          ActiveModel::Errors.new(self).tap do |errors|
+            apply_response_errors(errors)
+            apply_body_errors(errors)
+          end.freeze
+        end
+
+        private
+        def apply_response_errors(errors)
+          if response.http_error?
+            errors.add(:base, "HTTP error")
+          elsif response.soap_fault?
+            errors.add(:base, "SOAP error")
+          elsif !response.success?
+            errors.add(:base, "Request failed")
+          end
+        end
+
+        def apply_body_errors(errors)
+          body.css("ErrorList Error").each do |error|
+            errors.add(:base, [
+              (sm = error.at_css("Message")) && sm.content,
+              (dm = error.at_css("DetailedMessage")) && dm.content
+            ].compact.join("\n"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hotel_beds/hotel_search/parser/hotel.rb

@@ -0,0 +1,67 @@
+require "ostruct"
+require "hotel_beds/model/hotel"
+require "hotel_beds/hotel_search/parser/room"
+require "hotel_beds/hotel_search/parser/room_grouper"
+
+module HotelBeds
+  module HotelSearch
+    module Parser
+      class Hotel
+        def self.call(*args, &block)
+          new(*args, &block).call
+        end
+
+        attr_accessor :hotel, :currency, :request
+        private :hotel=, :currency=, :request=
+
+        def initialize(hotel:, currency:, request:)
+          self.hotel = hotel
+          self.currency = currency
+          self.request = request
+          freeze
+        end
+
+        def call
+          HotelBeds::Model::Hotel.new({
+            availability_token: hotel.attr("availToken"),
+            id: hotel.at_css("HotelInfo Code").content,
+            name: hotel.at_css("HotelInfo Name").content,
+            images: hotel.css("HotelInfo ImageList Image Url").map(&:content),
+            latitude: hotel.at_css("HotelInfo Position").attr("latitude"),
+            longitude: hotel.at_css("HotelInfo Position").attr("longitude"),
+            results: results,
+            destination_code: hotel.at_css("HotelInfo Destination").attr("code"),
+            contract_name: hotel.at_css("ContractList Contract Name").content,
+            contract_incoming_office_code: hotel.at_css("ContractList Contract IncomingOffice").attr("code")
+          })
+        end
+
+        private
+        def rooms
+          hotel.css("AvailableRoom")
+        end
+
+        def results
+          group_rooms(parsed_available_rooms).map do |rooms|
+            { rooms: Array(rooms), currency: currency }
+          end
+        end
+
+        def group_rooms(rooms)
+          if request.group_results?
+            grouper = HotelBeds::HotelSearch::Parser::RoomGrouper
+            grouper.new(request.rooms, rooms).results
+          else
+            rooms
+          end
+        end
+
+        def parsed_available_rooms
+          Array(rooms).map do |room|
+            HotelBeds::HotelSearch::Parser::Room.call(room)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hotel_beds/hotel_search/parser/price.rb

@@ -0,0 +1,38 @@
+module HotelBeds
+  module HotelSearch
+    module Parser
+      class Price
+        def self.call(*args, &block)
+          new(*args, &block).call
+        end
+
+        attr_accessor :price
+        private :price
+
+        def initialize(price)
+          self.price = price
+          freeze
+        end
+
+        def call
+          (from..to).to_a.inject(Hash.new) do |result, date|
+            result.merge!(date => amount)
+          end
+        end
+
+        private
+        def from
+          Date.parse(price.at_css("DateTimeFrom").attr("date"))
+        end
+
+        def to
+          Date.parse(price.at_css("DateTimeTo").attr("date"))
+        end
+
+        def amount
+          BigDecimal.new(price.at_css("Amount").content, 3)
+        end
+      end
+    end
+  end
+end

data/lib/hotel_beds/hotel_search/parser/room.rb

@@ -0,0 +1,46 @@
+require "hotel_beds/hotel_search/parser/price"
+require "hotel_beds/model/available_room"
+
+module HotelBeds
+  module HotelSearch
+    module Parser
+      class Room
+        def self.call(*args, &block)
+          new(*args, &block).call
+        end
+
+        attr_accessor :room
+        private :room=
+
+        def initialize(room)
+          self.room = room
+          freeze
+        end
+
+        def call
+          HotelBeds::Model::AvailableRoom.new({
+            id: room.at_css("HotelRoom").attr("SHRUI"),
+            room_count: room.at_css("HotelOccupancy RoomCount").content,
+            adult_count: room.at_css("HotelOccupancy AdultCount").content,
+            child_count: room.at_css("HotelOccupancy ChildCount").content,
+            number_available: room.at_css("HotelRoom").attr("availCount"),
+            description: room.at_css("HotelRoom RoomType").content,
+            board: room.at_css("HotelRoom Board").content,
+            board_code: room.at_css("HotelRoom Board").attr("code"),
+            room_type_code: room.at_css("HotelRoom RoomType").attr("code"),
+            room_type_characteristic: room.at_css("HotelRoom RoomType").attr("characteristic"),
+            price: ((room.at_css("HotelRoom") > "Price") > "Amount").first.content,
+            rates: parse_price_list(room.css("Price PriceList Price"))
+          })
+        end
+
+        private
+        def parse_price_list(prices)
+          Array(prices).map do |price|
+            HotelBeds::HotelSearch::Parser::Price.call(price)
+          end.inject(Hash.new, :merge)
+        end
+      end
+    end
+  end
+end

data/lib/hotel_beds/hotel_search/parser/room_grouper.rb

@@ -0,0 +1,101 @@
+# see INTERNALS.md for comment symbols
+module HotelBeds
+  module HotelSearch
+    module Parser
+      class RoomGrouper < Struct.new(:requested_rooms, :response_rooms)
+        def results
+          unique_room_combinations
+        end
+
+        private
+        def unique_room_combinations
+          combinations = build_combinations(room_options_grouped_by_occupants)
+          unique_combinations(expand_combinations(combinations))
+        end
+
+        def unique_combinations(combinations)
+          combinations.uniq { |r| r.sort_by(&:id).map(&:id) }
+        end
+
+        def expand_combinations(combinations)
+          combinations.map do |rooms|
+            rooms.inject(Array.new) do |result, room|
+              # get an array of all the child ages
+              child_ages = requested_rooms_child_ages_by_occupants.fetch(occupant_key(room))
+              1.upto(room.room_count) do |i|
+                result << room.dup.tap do |r|
+                  r.room_count = 1
+                  r.child_ages = child_ages.pop
+                end
+              end
+              result
+            end
+          end
+        end
+
+        # returns an array of room combinations for all rooms
+        def build_combinations(combinations)
+          head, *rest = combinations
+          Array(head).product(*rest)
+        end
+
+        # returns a array of arrays, each contains available rooms for a given
+        # room occupancy
+        def room_options_grouped_by_occupants
+          requested_room_count_by_occupants.inject(Array.new) do |result, (key, count)|
+            result << response_rooms_by_occupants.fetch(key).select do |room|
+              room.room_count == count
+            end
+          end
+        rescue KeyError => e
+          Array.new
+        end
+
+        # returns a hash of OK => [Integer]
+        def requested_rooms_child_ages_by_occupants
+          requested_rooms.inject(Hash.new) do |result, room|
+            key = occupant_key(room)
+            result[key] ||= Array.new
+            result[key] += room.child_ages
+            result
+          end
+        end
+
+        # returns a hash of OK => [RR]
+        def requested_rooms_by_occupants
+          requested_rooms.inject(Hash.new) do |result, room|
+            key = occupant_key(room)
+            result[key] ||= Array.new
+            result[key] << room
+            result
+          end
+        end
+
+        # returns a hash of OK => 1 (count)
+        def requested_room_count_by_occupants
+          requested_rooms_by_occupants.inject(Hash.new) do |result, (key, rooms)|
+            result.merge(key => rooms.size)
+          end
+        end
+
+        # returns a hash of OK => [AvailableRoom, AvailableRoom, AvailableRoom]
+        def response_rooms_by_occupants
+          response_rooms.inject(Hash.new) do |result, room|
+            key = occupant_key(room)
+            result[key] ||= Array.new
+            result[key].push(room)
+            result
+          end
+        end
+
+        # returns an OK for a given room
+        def occupant_key(room)
+          {
+            adult_count: room.adult_count,
+            child_count: room.child_count
+          }
+        end
+      end
+    end
+  end
+end

data/lib/hotel_beds/hotel_search/request.rb

@@ -1,44 +1,26 @@
+require "securerandom"
 require "hotel_beds/model"
+require "hotel_beds/model/requested_room"
 
 module HotelBeds
   module HotelSearch
     class Request
-      class Room
-        include HotelBeds::Model
-
-        # attributes
-        attribute :adult_count, Integer, default: 0
-        attribute :child_count, Integer, default: 0
-        attribute :child_ages, Array[Integer], default: Array.new
-
-        # validation
-        validates :adult_count, :child_count, numericality: {
-          greater_than_or_equal_to: 0,
-          less_than_or_equal_to: 4,
-          only_integer: true,
-        }
-        validate do |room|
-          unless child_ages.compact.size == child_count
-            room.errors.add(:child_ages, "must match quantity of children")
-          end
-        end
-      end
-
       include HotelBeds::Model
 
       # attributes
+      attribute :session_id, String, default: SecureRandom.hex[0..15]
       attribute :page_number, Integer, default: 1
       attribute :language, String, default: "ENG"
       attribute :check_in_date, Date
       attribute :check_out_date, Date
       attribute :destination, String
       attribute :hotels, Array[Integer]
-      attribute :rooms, Array[Room]
+      attribute :rooms, Array[HotelBeds::Model::RequestedRoom]
       attribute :group_results, Virtus::Attribute::Boolean, default: false
 
       # validation
       validates :language, :destination, length: { is: 3 }
-      validates :check_in_date, :check_out_date, presence: true
+      validates :session_id, :check_in_date, :check_out_date, presence: true
       validates :rooms, length: { minimum: 1, maximum: 5 }
       validates :page_number, numericality: {
         greater_than: 0, only_integer: true

data/lib/hotel_beds/hotel_search/response.rb

@@ -1,7 +1,6 @@
-require "active_model/errors"
 require "hotel_beds/model/hotel"
-require "hotel_beds/model/available_room"
-require_relative "room_grouper"
+require "hotel_beds/hotel_search/parser/errors"
+require "hotel_beds/hotel_search/parser/hotel"
 
 module HotelBeds
   module HotelSearch
@@ -13,22 +12,7 @@ module HotelBeds
         self.request = request
         self.headers = response.header
         self.body = Nokogiri::XML(response.body.fetch(:get_hotel_valued_avail))
-        self.errors = ActiveModel::Errors.new(self).tap do |errors|
-          if response.http_error?
-            errors.add(:base, "HTTP error")
-          elsif response.soap_fault?
-            errors.add(:base, "SOAP error")
-          elsif !response.success?
-            errors.add(:base, "Request failed")
-          end
-
-          body.css("ErrorList Error").each do |error|
-            errors.add(:base, [
-              (sm = error.at_css("Message")) && sm.content,
-              (dm = error.at_css("DetailedMessage")) && dm.content
-            ].compact.join("\n"))
-          end
-        end
+        self.errors = HotelBeds::HotelSearch::Parser::Errors.call(response, body)
         freeze
       end
 
@@ -36,6 +20,10 @@ module HotelBeds
         "<#{self.class.name} errors=#{errors.inspect} headers=#{headers.inspect} body=#{body.to_s}>"
       end
 
+      def session_id
+        request.session_id
+      end
+
       def current_page
         if data = pagination_data
           Integer(data.attr("currentPage"))
@@ -52,16 +40,17 @@ module HotelBeds
         end
       end
 
+      def currency
+        body.at_css("Currency").attr("code")
+      end
+
       def hotels
         body.css("ServiceHotel").lazy.map do |hotel|
-          HotelBeds::Model::Hotel.new({
-            id: hotel.at_css("HotelInfo Code").content,
-            name: hotel.at_css("HotelInfo Name").content,
-            images: hotel.css("HotelInfo ImageList Image Url").map(&:content),
-            latitude: hotel.at_css("HotelInfo Position").attr("latitude"),
-            longitude: hotel.at_css("HotelInfo Position").attr("longitude"),
-            results: generate_results(hotel.css("AvailableRoom"))
-          })
+          HotelBeds::HotelSearch::Parser::Hotel.call(
+            hotel: hotel,
+            currency: currency,
+            request: request
+          )
         end
       end
 
@@ -69,47 +58,6 @@ module HotelBeds
       def pagination_data
         body.at_css("PaginationData")
       end
-
-      def generate_results(rooms)
-        parsed_rooms = parse_available_rooms(rooms)
-        if request.group_results?
-          parsed_rooms = RoomGrouper.new(request.rooms, parsed_rooms).results
-        end
-        parsed_rooms.map do |rooms|
-          HotelBeds::Model::SearchResult.new({
-            rooms: Array(rooms),
-            currency: body.at_css("Currency").attr("code")
-          })
-        end
-      end
-
-      def parse_available_rooms(rooms)
-        Array(rooms).map do |room|
-          HotelBeds::Model::AvailableRoom.new({
-            id: room.at_css("HotelRoom").attr("SHRUI"),
-            adult_count: room.at_css("HotelOccupancy AdultCount").content,
-            child_count: room.at_css("HotelOccupancy ChildCount").content,
-            number_available: room.at_css("HotelRoom").attr("availCount"),
-            description: room.at_css("HotelRoom RoomType").content,
-            board: room.at_css("HotelRoom Board").content,
-            price: ((room.at_css("HotelRoom") > "Price") > "Amount").first.content,
-            rates: parse_price_list(room.css("Price PriceList Price"))
-          })
-        end
-      end
-
-      def parse_price_list(prices)
-        Array(prices).inject({}) do |result, price|
-          from = Date.parse(price.at_css("DateTimeFrom").attr("date"))
-          to = Date.parse(price.at_css("DateTimeTo").attr("date"))
-          dates = (from..to).to_a
-          amount = BigDecimal.new(price.at_css("Amount").content, 3)
-          dates.each do |date|
-            result.merge!(date => amount)
-          end
-          result
-        end
-      end
     end
   end
 end