hotel_beds 0.3.2 → 0.4.0

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

@@ -1,71 +0,0 @@
-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,
-              check_in_date: request.check_in_date,
-              check_out_date: request.check_out_date
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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, :check_in_date, :check_out_date
-        private :room=, :check_in_date=, :check_out_date=
-
-        def initialize(room, check_in_date:, check_out_date:)
-          self.room = room
-          self.check_in_date = check_in_date
-          self.check_out_date = check_out_date
-          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: total_price,
-            rates: parse_price_list(room.css("Price PriceList Price"))
-          })
-        end
-
-        private
-        def total_price
-          raw = ((room.at_css("HotelRoom") > "Price") > "Amount").first.content
-          BigDecimal.new(raw.to_s)
-        end
-
-        def parse_price_list(prices)
-          if prices.empty?
-            dates = (check_in_date..check_out_date).to_a
-            amount = total_price / dates.size
-            dates.inject(Hash.new) do |result, date|
-              result.merge(date => amount)
-            end
-          else
-            Array(prices).map do |price|
-              HotelBeds::HotelSearch::Parser::Price.call(price)
-            end.inject(Hash.new, :merge)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-# 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/spec/features/adding_a_hotel_to_basket_spec.rb

@@ -1,58 +0,0 @@
-require "hotel_beds"
-
-RSpec.describe "adding a hotel to the basket" do
-  describe "#response" do
-    before(:all) do
-      @client = HotelBeds::Client.new({
-        endpoint: :test,
-        username: ENV.fetch("HOTEL_BEDS_USERNAME"),
-        password: ENV.fetch("HOTEL_BEDS_PASSWORD"),
-        proxy: ENV.fetch("HOTEL_BEDS_PROXY", nil)
-      })
-      @check_in_date = Date.today + 28 + rand(10)
-      @check_out_date = @check_in_date + rand(3) + rand(2) + 1
-      @search_response = @client.perform_hotel_search({
-        check_in_date: @check_in_date,
-        check_out_date: @check_out_date,
-        rooms: [{ adult_count: 2 }],
-        destination: "SYD"
-      }).response
-
-      hotel = @search_response.hotels.first
-      result = hotel.results.first
-
-      @operation = @client.add_hotel_room_to_basket({
-        service: {
-          check_in_date: @check_in_date,
-          check_out_date: @check_out_date,
-          availability_token: hotel.availability_token,
-          hotel_code: hotel.id,
-          destination_code: hotel.destination_code,
-          contract_name: hotel.contract_name,
-          contract_incoming_office_code: hotel.contract_incoming_office_code,
-          rooms: result.rooms
-        }
-      })
-      if @operation.errors.any?
-        raise StandardError, @operation.errors.full_messages.join("\n")
-      end
-      @response = @operation.response
-    end
-
-    let(:response) { @response }
-
-    subject { response }
-
-    it "should be a success" do
-      expect(subject).to be_success
-    end
-
-    describe "#purchase" do
-      subject { response.purchase }
-
-      it "should have a service" do
-        expect(subject.services).to_not be_empty
-      end
-    end
-  end
-end

data/spec/features/grouped_hotel_search_spec.rb

@@ -1,67 +0,0 @@
-require "hotel_beds"
-
-RSpec.describe "performing a grouped hotel search" do
-  describe "#response" do
-    before(:all) do
-      @client = HotelBeds::Client.new({
-        endpoint: :test,
-        username: ENV.fetch("HOTEL_BEDS_USERNAME"),
-        password: ENV.fetch("HOTEL_BEDS_PASSWORD"),
-        proxy: ENV.fetch("HOTEL_BEDS_PROXY", nil)
-      })
-      @check_in_date = Date.today + 28 + rand(10)
-      @check_out_date = @check_in_date + rand(3) + rand(2) + 1
-      @operation = @client.perform_hotel_search({
-        check_in_date: @check_in_date,
-        check_out_date: @check_out_date,
-        rooms: [
-          { adult_count: 2 },
-          { adult_count: 1, child_count: 1, child_ages: [rand(17)] }
-        ],
-        destination: "SYD",
-        group_results: true
-      })
-      if @operation.errors.any?
-        raise StandardError, @operation.errors.full_messages.join("\n")
-      end
-      @response = @operation.response
-    end
-
-    let(:check_in_date) { @check_in_date }
-    let(:check_out_date) { @check_out_date }
-    let(:response) { @response }
-
-    describe "#errors" do
-      subject { response.errors }
-
-      it "should be empty" do
-        expect(subject).to be_empty
-      end
-    end
-
-    describe "#hotels" do
-      subject { response.hotels }
-
-      it "should have room counts to match the searched room count" do
-        room_counts = subject.map { |h| h.results.map { |r| r.rooms.size } }
-        expect(room_counts.to_a.flatten.uniq).to eq([response.request.rooms.size])
-      end
-    end
-
-    describe "#current_page" do
-      subject { response.current_page }
-
-      it "should return '1'" do
-        expect(subject).to eq(1)
-      end
-    end
-
-    describe "#total_pages" do
-      subject { response.total_pages }
-
-      it "should be greater or equal to current page" do
-        expect(subject).to be >= response.current_page
-      end
-    end
-  end
-end

data/spec/features/hotel_search_spec.rb

@@ -1,113 +0,0 @@
-require "hotel_beds"
-
-RSpec.describe "performing a hotel search" do
-  describe "#response" do
-    before(:all) do
-      @client = HotelBeds::Client.new({
-        endpoint: :test,
-        username: ENV.fetch("HOTEL_BEDS_USERNAME"),
-        password: ENV.fetch("HOTEL_BEDS_PASSWORD"),
-        proxy: ENV.fetch("HOTEL_BEDS_PROXY", nil)
-      })
-      @stay_length_in_days = rand(3) + 1
-      @check_in_date = Date.today + 28 + rand(10)
-      @check_out_date = @check_in_date + @stay_length_in_days
-      @response = @client.perform_hotel_search({
-        check_in_date: @check_in_date,
-        check_out_date: @check_out_date,
-        rooms: [{ adult_count: 2 }],
-        destination: "SYD"
-      }).response
-    end
-
-    let(:check_in_date) { @check_in_date }
-    let(:check_out_date) { @check_out_date }
-    let(:stay_length_in_days) { @stay_length_in_days }
-    let(:response) { @response }
-
-    describe "#errors" do
-      subject { response.errors }
-
-      it "should be empty" do
-        expect(subject).to be_empty
-      end
-    end
-
-    describe "#hotels" do
-      subject { response.hotels }
-
-      it "should return an array of the hotels available" do
-        expect(subject.to_a).to be_kind_of(Array)
-        expect(subject.to_a).to_not be_empty
-        expect(subject.first).to be_kind_of(HotelBeds::Model::Hotel)
-      end
-
-      it "should only have one room per result" do
-        room_counts = subject.map { |h| h.results.map { |r| r.rooms.size } }
-        expect(room_counts.to_a.flatten.uniq).to eq([1])
-      end
-
-      it "should have a destination code" do
-        subject.each do |hotel|
-          expect(hotel.destination_code).to be_present
-        end
-      end
-
-      it "should have an availability token" do
-        subject.each do |hotel|
-          expect(hotel.availability_token).to be_present
-        end
-      end
-
-      it "should have a contract name" do
-        subject.each do |hotel|
-          expect(hotel.contract_name).to be_present
-        end
-      end
-
-      it "should have a contract incoming office code" do
-        subject.each do |hotel|
-          expect(hotel.contract_incoming_office_code).to be_present
-        end
-      end
-
-      describe "#results" do
-        describe "#rooms" do
-          subject do
-            results = response.hotels.map(&:results).to_a.flatten
-            results.map(&:rooms).to_a.flatten
-          end
-
-          it "should parse the rates correctly" do
-            subject.each do |room|
-              expect(room.price).to eq(room.rates.values.inject(:+))
-            end
-          end
-
-          it "should have the same number of rates as nights requested" do
-            subject.each do |room|
-              expect(room.rates).to_not be_empty
-              expect(room.rates.size).to eq(stay_length_in_days)
-            end
-          end
-        end
-      end
-    end
-
-    describe "#current_page" do
-      subject { response.current_page }
-
-      it "should return '1'" do
-        expect(subject).to eq(1)
-      end
-    end
-
-    describe "#total_pages" do
-      subject { response.total_pages }
-
-      it "should be greater or equal to current page" do
-        expect(subject).to be >= response.current_page
-      end
-    end
-  end
-end