hotel_beds 0.3.2 → 0.4.0

data/lib/hotel_beds/parser/price.rb

@@ -0,0 +1,14 @@
+require "hotel_beds/parser"
+
+module HotelBeds
+  module Parser
+    class Price
+      include HotelBeds::Parser
+
+      # attributes
+      attribute :from, selector: "DateTimeFrom", attr: "date"
+      attribute :to, selector: "DateTimeTo", attr: "date"
+      attribute :amount, selector: "Amount"
+    end
+  end
+end

data/lib/hotel_beds/parser/purchase.rb

@@ -0,0 +1,24 @@
+require "hotel_beds/parser"
+require "hotel_beds/parser/service"
+require "hotel_beds/parser/customer"
+
+module HotelBeds
+  module Parser
+    class Purchase
+      include HotelBeds::Parser
+
+      # attributes
+      attribute :token, attr: "purchaseToken"
+      attribute :time_to_expiration, attr: "timeToExpiration"
+      attribute :agency_reference, selector: "AgencyReference"
+      attribute :status, selector: "Status"
+      attribute :currency, selector: "Currency", attr: "code"
+      attribute :amount, selector: "TotalPrice"
+      attribute :services,
+        selector: "ServiceList > Service", multiple: true,
+        parser: HotelBeds::Parser::Service
+      attribute :holder, selector: "Holder",
+        parser: HotelBeds::Parser::Customer
+    end
+  end
+end

data/lib/hotel_beds/parser/room_grouper.rb

@@ -0,0 +1,104 @@
+# see INTERNALS.md for comment symbols
+module HotelBeds
+  module Parser
+    class RoomGrouper
+      attr_accessor :requested_rooms, :response_rooms
+      private :requested_rooms=, :response_rooms=
+
+      def initialize(requested_rooms, response_rooms)
+        self.requested_rooms = requested_rooms
+        self.response_rooms = response_rooms
+        freeze
+      end
+
+      def groups
+        combinations = build_combinations(room_options_grouped_by_occupants)
+        unique_combinations(expand_combinations(combinations))
+      end
+
+      private
+      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

data/lib/hotel_beds/parser/service.rb

@@ -0,0 +1,21 @@
+require "hotel_beds/parser"
+require "hotel_beds/parser/contract"
+
+module HotelBeds
+  module Parser
+    class Service
+      include HotelBeds::Parser
+
+      # attributes
+      attribute :id, attr: "SPUI"
+      attribute :type, attr: "xsi:type"
+      attribute :status, selector: "Status"
+      attribute :date_from, selector: "DateFrom", attr: "date"
+      attribute :date_to, selector: "DateTo", attr: "date"
+      attribute :currency, selector: "Currency", attr: "code"
+      attribute :amount, selector: "TotalAmount"
+      attribute :contract, selector: "Contract",
+        parser: HotelBeds::Parser::Contract
+    end
+  end
+end

data/lib/hotel_beds/purchase_confirm/envelope.rb

@@ -0,0 +1,42 @@
+require "delegate"
+
+module HotelBeds
+  module PurchaseConfirm
+    class Envelope < SimpleDelegator
+      def attributes
+        {
+          Language: language,
+          ConfirmationData: {
+            :"@purchaseToken" => purchase.token,
+            :Holder => customer(purchase.holder),
+            :AgencyReference => purchase.agency_reference,
+            :ConfirmationServiceDataList => {
+              :ServiceData => purchase.services.map(&method(:service_data))
+            }
+          }
+        }
+      end
+
+      private
+      def service_data(service)
+        {
+          :@SPUI => service.id,
+          :"@xsi:type" => "ConfirmationServiceDataHotel",
+          :CustomerList => {
+            :Customer => service.customers.map(&method(:customer))
+          }
+        }
+      end
+
+      def customer(customer)
+        {
+          :@type => (:child == customer.type ? "CH" : "AD"),
+          :CustomerId => customer.id,
+          :Age => customer.age,
+          :Name => customer.name,
+          :LastName => customer.last_name,
+        }
+      end
+    end
+  end
+end

data/lib/hotel_beds/purchase_confirm/operation.rb

@@ -0,0 +1,36 @@
+require_relative "request"
+require_relative "response"
+require_relative "envelope"
+
+module HotelBeds
+  module PurchaseConfirm
+    class Operation
+      attr_accessor :request, :response, :errors
+      private :request=, :response=, :errors=
+
+      def initialize(*args)
+        self.request = Request.new(*args)
+      end
+
+      def perform(connection:)
+        if request.valid?
+          self.response = Response.new(request, retrieve(connection))
+          self.errors = response.errors
+        else
+          self.errors = request.errors
+        end
+        freeze
+        self
+      end
+
+      private
+      def retrieve(connection)
+        connection.call({
+          method: :purchaseConfirm,
+          namespace: :PurchaseConfirmRQ,
+          data: Envelope.new(request).attributes
+        })
+      end
+    end
+  end
+end

data/lib/hotel_beds/purchase_confirm/request.rb

@@ -0,0 +1,72 @@
+require "securerandom"
+require "hotel_beds/model"
+require "hotel_beds/model/customer"
+
+module HotelBeds
+  module PurchaseConfirm
+    class Request
+      class Service
+        include HotelBeds::Model
+
+        # attributes
+        attribute :id, String
+        attribute :type, String
+        attribute :customers, Array[HotelBeds::Model::Customer]
+
+        # validation
+        validates :customers, length: { minimum: 1 }
+        validates :id, :type, presence: true
+        validate do |service|
+          unless service.customers.all?(&:valid?)
+            service.errors.add(:customers, "are invalid")
+          end
+        end
+      end
+
+      class Purchase
+        include HotelBeds::Model
+
+        # attributes
+        attribute :token, String
+        attribute :holder, HotelBeds::Model::Customer
+        attribute :agency_reference, String
+        attribute :services, Array[Service]
+
+        # validation
+        validates :services, length: { minimum: 1 }
+        validates :token, :agency_reference, :holder, presence: true
+        validate do |purchase|
+          purchase.services.each do |service|
+            unless service.valid?
+              service.errors.full_messages.each do |message|
+                purchase.errors.add(:services, message)
+              end
+            end
+          end
+          if purchase.holder && purchase.holder.invalid?
+            purchase.holder.errors.full_messages.each do |message|
+              purchase.errors.add(:holder, message)
+            end
+          end
+        end
+      end
+
+      include HotelBeds::Model
+
+      # attributes
+      attribute :language, String, default: "ENG"
+      attribute :purchase, Purchase
+
+      # validation
+      validates :language, length: { is: 3 }
+      validates :purchase, presence: true
+      validate do |request|
+        if request.purchase && request.purchase.invalid?
+          request.purchase.errors.full_messages.each do |message|
+            request.errors.add(:purchase, message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hotel_beds/purchase_confirm/response.rb

@@ -0,0 +1,31 @@
+require "hotel_beds/parser/errors"
+require "hotel_beds/parser/purchase"
+
+module HotelBeds
+  module PurchaseConfirm
+    class Response
+      attr_accessor :request, :headers, :body, :errors
+      private :request=, :headers=, :body=, :errors=
+
+      def initialize(request, response)
+        self.request = request
+        self.headers = response.header
+        self.body = Nokogiri::XML(response.body.fetch(:purchase_confirm))
+        self.errors = HotelBeds::Parser::Errors.new(response).to_model(self)
+        freeze
+      end
+
+      def inspect
+        "<#{self.class.name} errors=#{errors.inspect} headers=#{headers.inspect} body=#{body.to_s}>"
+      end
+
+      def success?
+        errors.empty?
+      end
+
+      def purchase
+        HotelBeds::Parser::Purchase.new(body.at_css("Purchase")).to_model
+      end
+    end
+  end
+end

data/lib/hotel_beds/purchase_flush/envelope.rb

@@ -0,0 +1,15 @@
+require "delegate"
+
+module HotelBeds
+  module PurchaseFlush
+    class Envelope < SimpleDelegator
+      def attributes
+        {
+          :Language => language,
+          :@version => "2013/12",
+          :@purchaseToken => purchase_token
+        }
+      end
+    end
+  end
+end

data/lib/hotel_beds/purchase_flush/operation.rb

@@ -0,0 +1,36 @@
+require_relative "request"
+require_relative "response"
+require_relative "envelope"
+
+module HotelBeds
+  module PurchaseFlush
+    class Operation
+      attr_accessor :request, :response, :errors
+      private :request=, :response=, :errors=
+
+      def initialize(*args)
+        self.request = Request.new(*args)
+      end
+
+      def perform(connection:)
+        if request.valid?
+          self.response = Response.new(request, retrieve(connection))
+          self.errors = response.errors
+        else
+          self.errors = request.errors
+        end
+        freeze
+        self
+      end
+
+      private
+      def retrieve(connection)
+        connection.call({
+          method: :purchaseFlush,
+          namespace: :PurchaseFlushRQ,
+          data: Envelope.new(request).attributes
+        })
+      end
+    end
+  end
+end

data/lib/hotel_beds/purchase_flush/request.rb

@@ -0,0 +1,17 @@
+require "hotel_beds/model"
+
+module HotelBeds
+  module PurchaseFlush
+    class Request
+      include HotelBeds::Model
+
+      # attributes
+      attribute :language, String, default: "ENG"
+      attribute :purchase_token, String
+
+      # validation
+      validates :language, length: { is: 3 }
+      validates :purchase_token, presence: true
+    end
+  end
+end

data/lib/hotel_beds/purchase_flush/response.rb

@@ -0,0 +1,26 @@
+require "hotel_beds/parser/errors"
+
+module HotelBeds
+  module PurchaseFlush
+    class Response
+      attr_accessor :request, :headers, :body, :errors
+      private :request=, :headers=, :body=, :errors=
+
+      def initialize(request, response)
+        self.request = request
+        self.headers = response.header
+        self.body = Nokogiri::XML(response.body.fetch(:purchase_flush))
+        self.errors = HotelBeds::Parser::Errors.new(response).to_model(self)
+        freeze
+      end
+
+      def inspect
+        "<#{self.class.name} errors=#{errors.inspect} headers=#{headers.inspect} body=#{body.to_s}>"
+      end
+
+      def success?
+        errors.empty? && body.at_css("Status").content == "Y"
+      end
+    end
+  end
+end