parsec_client 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 79dc7741365756dd9fd8286225be1d30811cf500f22eff258a20a06eeee9f322
+  data.tar.gz: 5d5e78a36f30c0f6e88a29f6bbc7d9479ba354070b4599012aa61db58cac13d0
+SHA512:
+  metadata.gz: e2ff815e3b14c501d91b40c915a98377608a3c66a8ab3cce8a75e8b914742ebf9103f4bcd62794f971b1cb46b1a03f7487a8c3cdbeecc740bbe368d0f9f89d07
+  data.tar.gz: 474d1559f3b861f137e983e9cbfecb5607398ae09e25408ff5773cb6128acaa63e9d1f36d278ac7484cb3761218bcba5821f0ad7efc30f0bc87cf675a55637b1

data/lib/parsec.rb

@@ -0,0 +1,17 @@
+module Parsec
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  def self.configure
+    yield configuration 
+  end
+end

data/lib/parsec/availability.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Parsec
+  class Availability < Base
+    MEAL_PLANS = {
+      'RO' => 'Room Only',
+      'BB' => 'Breakfast is included',
+      'HB' => 'Half board (two meals) included',
+      'FB' => 'Full board (three meals) included',
+      'AI' => 'All Inclusive'
+    }.freeze
+
+    PACKAGE_RATES_CODE = 'PK'
+
+    attr_reader :hotel_code, :hotel_provider_code, :room_code, :room_name, :rates, :rph, :description, :extra, :special
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(hotel_code:, hotel_provider_code: nil, room_code: nil, room_name: nil, rates:,
+                   rph: nil, description: nil, extra: nil, special: nil, package: false)
+      @hotel_code = hotel_code
+      @hotel_provider_code = hotel_provider_code
+      @room_code = room_code
+      @room_name = room_name
+      @package = package
+      @rates = rates
+      @rph = rph
+      @description = description
+      @extra = extra
+      @special = special
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def package_rates?
+      @package
+    end
+
+    class << self
+      # rubocop:disable Metrics/AbcSize
+      def build(room, hotel_info, nights)
+        new(hotel_code: hotel_info[:@hotel_code],
+            hotel_provider_code: hotel_info[:hotel_provider_code],
+            room_code: room[:room_type][:@code],
+            room_name: room[:room_type][:@name],
+            package: package_rates?(room),
+            description: room[:room_type][:description],
+            extra: room[:room_type].dig(:extra_info, :msg),
+            special: room[:room_type][:special],
+            rates: Array.wrap(room[:room_rates][:room_rate]).map { |rate| build_rate(rate, nights) },
+            rph: room[:@rph].split(',').first)
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def search(room, hotel_code)
+        new(hotel_code: hotel_code,
+            package: package_rates?(room),
+            rates: Array.wrap(room[:room_rates][:room_rate]).map { |rate| build_rate(rate) })
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/LineLength
+      def build_rate(rate, nights = 1)
+        price = rate[:total][:@amount].to_f.ceil
+        { price: price,
+          price_per_night: (price.to_f / nights).round(2),
+          net_price: rate[:cost][:@amount].to_f,
+          cancellation: build_customer_cancellation(rate[:cancel_penalties], Array.wrap(rate[:rates][:rate])[0][:@effective_date]),
+          penalties: build_cancellation(rate[:cancel_penalties]),
+          deadline: build_deadline_date(rate[:cancel_penalties], Array.wrap(rate[:rates][:rate])[0][:@effective_date]),
+          meal_plan: MEAL_PLANS[rate[:@meal_plan]],
+          booking_code: rate[:@booking_code] }
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/LineLength
+
+      def build_cancellation(cancellation)
+        # return if cancellation.nil?
+        return 'Non-refundable rate' if cancellation[:@non_refundable] == '1'
+
+        penalties = Array.wrap(cancellation[:cancel_penalty]).map { |p| build_penalty(p) }
+        penalties << cancellation[:description] if cancellation[:description].present?
+
+        penalties.join(' ')
+      end
+
+      def build_penalty(penalty)
+        p = [penalty[:deadline][:@units], penalty[:deadline][:@time_unit], '=', "$#{penalty[:charge][:@amount]};"]
+        p << "(#{penalty[:msg]})" if penalty[:msg].present?
+        p.join(' ')
+      end
+
+      def build_customer_cancellation(cancellation, start_date)
+        # return if cancellation.nil?
+        return 'Special non-refundable rate' if cancellation.slice(:@non_refundable, :@cancellation_costs_today).value?('1')
+
+        deadline = Array.wrap(cancellation[:cancel_penalty]).max_by { |p| p[:deadline][:@units].to_i }
+        return 'Free cancellation' if deadline.nil?
+
+        deadline_date = Date.strptime(start_date, self::DATE_FORMAT) - (deadline[:deadline][:@units].to_i + 1).days
+
+        "Free cancellation until #{deadline_date.strftime('%-d %B')} at 12:00PM, local time"
+      end
+
+      def build_deadline_date(cancellation, start_date)
+        return Time.zone.today if cancellation[:@non_refundable] == '1'
+
+        deadline = Array.wrap(cancellation[:cancel_penalty]).max_by { |p| p[:deadline][:@units].to_i }
+        Date.strptime(start_date, self::DATE_FORMAT) - (deadline&.dig(:deadline, :@units).to_i + 1).days
+      end
+
+      def package_rates?(room)
+        room[:room_type][:@product_type_info1] == PACKAGE_RATES_CODE
+      end
+    end
+  end
+end

data/lib/parsec/base.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Parsec
+  class Base
+    DATE_FORMAT = '%Y-%m-%d'
+  end
+end

data/lib/parsec/city.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Parsec
+  class City < Base
+    attr_reader :code, :name, :country_iso
+
+    def initialize(code:, name: nil, country_iso: nil)
+      @code = code
+      @name = name
+      @country_iso = country_iso
+    end
+  end
+end

data/lib/parsec/configuration.rb

@@ -0,0 +1,12 @@
+module Parsec
+  class Configuration
+    attr_accessor :username, :password, :context, :host
+
+    def initialize
+      @username = nil
+      @password = nil
+      @context = nil
+      @host = nil
+    end
+  end
+end

data/lib/parsec/country.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Parsec
+  class Country < Base
+    attr_reader :code, :name, :iso
+
+    def initialize(iso:, name: nil, code: nil)
+      @code = code
+      @name = name
+      @iso = iso
+    end
+  end
+end

data/lib/parsec/hotel.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Parsec
+  class Hotel < Base
+    attr_reader :code
+    attr_accessor :email, :phone, :fax, :location, :check_in, :check_out, :name, :rating, :address, :parsec_region_id,
+                  :hotel_facilities, :room_facilities, :entertainments, :points_of_interest, :additional_info, :facts,
+                  :parsec_location_id, :descriptions, :hotel_url, :images, :error
+
+    def initialize(code:, name: nil, rating: nil, address: nil)
+      @code = code
+      @name = name
+      @rating = rating
+      @address = address
+      @hotel_facilities = {}
+      @room_facilities = {}
+      @entertainments = {}
+      @additional_info = {}
+      @facts = {}
+      @points_of_interest = {}
+      @descriptions = {}
+      @images = []
+    end
+
+    def self.build(hotel_json)
+      hotel = new(code: hotel_json[:@hotel_code],
+                  name: hotel_json[:@hotel_name],
+                  rating: hotel_json[:award][:@rating])
+      # rooms: []) doesn't work now - this option has to be enabled on Parsec side
+      hotel.add_address(hotel_json[:address])
+      hotel.add_phones(Array.wrap(hotel_json.dig(:contact_numbers, :contact_number)))
+      hotel.email = hotel_json.dig(:tpa_extensions, :email)
+
+      hotel
+    end
+
+    def add_details(details_json)
+      return add_error if details_json[:@hotel_name].blank?
+
+      # self.name ||= details_json[:@hotel_name]
+      self.parsec_region_id ||= details_json[:@region_code]
+      self.parsec_location_id ||= details_json[:@location_code]
+      add_hotel_info(details_json[:hotel_info])
+      add_policy(details_json.dig(:policies, :policy, :policy_info))
+      add_contact_info(details_json[:contact_infos][:contact_info])
+      add_extentions(details_json[:tpa_extensions])
+    end
+
+    def add_hotel_info(hotel_info)
+      self.rating ||= hotel_info[:category_codes][:hotel_category][:@code]
+      # self.descriptions = Array.wrap(hotel_info.dig(:descriptions, :descriptive_text))
+      add_location(hotel_info[:position])
+    end
+
+    def add_location(position)
+      self.location = { lat: position[:@latitude], lon: position[:@longitude] }
+    end
+
+    def add_policy(policy)
+      return if policy.blank?
+
+      self.check_in = policy[:@check_in_time]
+      check_out_data = policy[:@check_out_time]
+      self.check_out = check_out_data.index('time').nil? ? check_out_data : JSON.parse(check_out_data)['time']
+    end
+
+    def add_contact_info(contact_info)
+      return if contact_info.blank?
+
+      self.email ||= contact_info.dig(:emails, :email)
+      # self.images = Array.wrap(contact_info.dig(:ur_ls, :url))
+      add_address(contact_info.dig(:addresses, :address))
+      add_phones(Array.wrap(contact_info.dig(:phones, :phone)))
+    end
+
+    FACTS_WHITE_LIST = %w[Kind Floors\ Number Rooms\ Number Year\ Built Year\ Renovated].freeze
+
+    # rubocop:disable Metrics/AbcSize, Metrics/LineLength
+    def add_extentions(extentions)
+      return if extentions.blank?
+
+      self.hotel_facilities = Array.wrap(extentions.dig(:hotel_facilities, :hotel_facility)).map { |f| transform_facility(f) }.to_h
+      self.room_facilities = Array.wrap(extentions.dig(:room_facilities, :room_facility)).map { |f| transform_facility(f) }.to_h
+      self.entertainments = Array.wrap(extentions.dig(:entertainments, :entertainment)).map { |f| transform_facility(f) }.to_h
+      self.additional_info = Array.wrap(extentions.dig(:additional_infos, :additional_info)).map { |f| transform_facility(f) }.to_h
+      self.facts = Array.wrap(extentions.dig(:facts, :fact)).map do |f|
+        ff = f[:@name].split(': ', 2)
+        ff.size == 1 ? ff << 'null' : ff
+      end.to_h.slice(*FACTS_WHITE_LIST)
+      self.points_of_interest = Array.wrap(extentions.dig(:points_of_interest, :point_of_interest))
+                                     .sort_by { |f| f[:@distance].to_i }.map { |f| transform_facility(f) }.to_h
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/LineLength
+
+    def transform_facility(facility)
+      [facility[:@name], facility.except(:@name).transform_keys { |k| k.to_s.delete('@') }]
+    end
+
+    def add_phones(contact_numbers)
+      return if contact_numbers.blank?
+
+      phone_number = find_phone(contact_numbers)
+      fax_number = find_fax(contact_numbers)
+      self.phone = phone_number if phone_number.present?
+      self.fax = fax_number if fax_number.present?
+    end
+
+    def add_address(address)
+      return if address.blank?
+      return if address[:address_line].blank?
+
+      self.address = [address[:address_line], address[:city_name], address[:country_name]].join(', ')
+    end
+
+    def find_phone(contact_numbers)
+      phone = contact_numbers.find { |number| number[:@phone_tech_type] == 'Phone' }
+      phone&.dig(:@phone_number)
+    end
+
+    def find_fax(contact_numbers)
+      fax = contact_numbers.find { |number| number[:@phone_tech_type] == 'Fax' }
+      fax&.dig(:@phone_number)
+    end
+
+    def add_error
+      self.error = 'Parsec doesn\'t provide hotel details'
+    end
+
+    def add_details_with_nokogiri(document)
+      info = Nokogiri::XML.parse(document.first_element_child
+                                         .last_element_child
+                                         .last_element_child
+                                         .last_element_child
+                                         .last_element_child.to_xml)
+
+      self.name = info.search('HotelDescriptiveContent').first.attributes['HotelName'].value
+
+      add_descriptions(info)
+      add_images(info)
+    end
+
+    def add_descriptions(info)
+      info.search('DescriptiveText').each do |desc|
+        title = desc.values.first.split(/(?=[A-Z])/).join(' ')
+        descriptions[title] = desc.content
+      end
+    end
+
+    def add_images(info)
+      info.search('URL').each do |url|
+        if url.values.first == 'Image'
+          images << url.content
+        elsif url.values.first == 'Hotel'
+          self.hotel_url = url.content
+        end
+      end
+    end
+  end
+end

data/lib/parsec/location.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Parsec
+  class Location < Base
+    attr_reader :code, :name, :country_iso
+
+    def initialize(code:, name: nil, city_code: nil, country_iso: nil)
+      @code = code
+      @name = name
+      @city_code = city_code
+      @country_iso = country_iso
+    end
+  end
+end

data/lib/parsec/order.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Parsec
+  class Order < Base
+    RES_STATUS = {
+      'OK' => 'Success', # 'New booking'
+      'CA' => 'Cancelled',
+      'OR' => 'On Request'
+    }.freeze
+
+    attr_reader :number, :rooms, :price, :hotel_code, :start_date, :end_date, :parsec_id, :status
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(product_item_id:, rooms:, price:, hotel_code:, start_date:, end_date:, parsec_id:, status:)
+      @product_item_id = product_item_id
+      @rooms = rooms
+      @price = price
+      @hotel_code = hotel_code
+      @start_date = start_date
+      @end_date = end_date
+      @parsec_id = parsec_id
+      @status = status
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    # rubocop:disable Metrics/AbcSize
+    def self.build(order_data)
+      hotel_data = order_data[:hotel_res_list][:hotel_res]
+      new(product_item_id: order_data[:res_global_info][:res_i_ds][:res_id].find { |id| id[:@type] == 'ClientReference' }[:@id],
+          rooms: Array.wrap(hotel_data[:rooms][:room]).map { |r| [r[:room_type][:@code], r[:room_type][:@name]] }.to_h,
+          hotel_code: hotel_data[:info][:@hotel_code],
+          start_date: Date.strptime(hotel_data[:hotel_res_info][:date_range][:@start], DATE_FORMAT),
+          end_date: Date.strptime(hotel_data[:hotel_res_info][:date_range][:@end], DATE_FORMAT),
+          price: hotel_data[:hotel_res_info][:total][:@amount].to_f,
+          parsec_id: hotel_data[:hotel_res_info][:hotel_res_i_ds][:hotel_res_id].find { |id| id[:@type] == 'Locator' }[:@id],
+          status: RES_STATUS[hotel_data[:@res_status]])
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/parsec/region.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Parsec
+  class Region < Base
+    attr_reader :code, :name, :country_iso
+
+    def initialize(code:, name: nil, country_iso: nil)
+      @code = code
+      @name = name
+      @country_iso = country_iso
+    end
+  end
+end

data/lib/parsec/request/availability.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Parsec
+  module Request
+    class Availability < Base
+      # rooms - array of room hashes, e.g. { rph1: { adults: 2, children: [5, 8]}, rph2: { adults: 3 }}
+      # rubocop:disable Metrics/AbcSize
+      def by_hotel(from_date, to_date, rooms, hotel_search_criteria)
+        hotels = availability_request(from_date, to_date, rooms, hotel_search_criteria)
+        return error(hotels[:ota_hotel_avail_rs]) if hotels[:ota_hotel_avail_rs][:errors].present?
+
+        Array.wrap(hotels[:ota_hotel_avail_rs][:hotels][:hotel]).map do |h|
+          Array.wrap(h[:rooms][:room]).map { |r| Parsec::Availability.build(r, h[:info], (to_date - from_date).to_i) }
+        end.flatten.group_by(&:hotel_code)
+      end
+
+      def search(from_date, to_date, rooms, search_criteria)
+        hotels = availability_request(from_date, to_date, rooms, search_criteria)
+        return error(hotels[:ota_hotel_avail_rs]) if hotels[:ota_hotel_avail_rs][:errors].present?
+
+        Array.wrap(hotels[:ota_hotel_avail_rs][:hotels][:hotel]).map do |h|
+          Array.wrap(h[:rooms][:room]).map { |r| Parsec::Availability.search(r, h[:info][:@hotel_code]) }
+        end.flatten.group_by(&:hotel_code)
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def availability_request(from_date, to_date, rooms, search_criteria)
+        attributes = { 'RateDetails' => '1', 'DetailLevel' => '1', 'CancelPenalties' => '1', 'Language' => 'EN' }
+        message = message(from_date, to_date, rooms_description(rooms), search_criteria)
+        response = client(:availability).call('OTA_HotelAvailRQ', attributes: attributes, message: message)
+
+        response.body
+      rescue Savon::Error => e
+        Xlog.and_raise_error(e)
+      end
+
+      private
+
+      def message(from_date, to_date, rooms, search_criteria)
+        {
+          hotel_search: {
+            # '@BestOnly' => '1',
+            '@AvailableOnly' => '1',
+            # '@FilterNonRefundable' => '1',
+            # '@FilterCancellationCostsToday' => '1',
+            currency: { '@Code' => 'USD' },
+            date_range: {
+              '@Start' => from_date.strftime(DATE_FORMAT),
+              '@End' => to_date.strftime(DATE_FORMAT)
+            },
+            room_candidates: { room_candidate: rooms }
+          }.merge!(search_criteria)
+        }
+      end
+
+      def rooms_description(rooms)
+        rooms.map do |rph, room_guests|
+          { '@RPH' => rph, guests: { guest: guests_description(room_guests.symbolize_keys) } }
+        end
+      end
+
+      def guests_description(adults:, children: nil)
+        guests = [{ '@AgeCode' => 'A', '@Count' => adults }]
+        children.each { |c| guests << { '@AgeCode' => 'C', '@Count' => 1, '@Age' => c } } if children.present?
+
+        guests
+      end
+    end
+  end
+end

data/lib/parsec/request/base.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Parsec
+  module Request
+    class Base
+      RESOURCES = {
+        static_data: 'staticdata/OTA2014A',
+        hotel_info: 'hotelinfo/OTA2014A',
+        availability: 'hotelavail/OTA2014Compact',
+        reservation: 'hotelres/OTA2014Compact',
+        list: 'bookinglist/OTA2014Compact',
+        read: 'reservationsread/OTA2014Compact',
+        cancel: 'hotelcancel/OTA2014Compact'
+      }.freeze
+
+      NAMESPACE = 'http://parsec.es/hotelapi/OTA2014Compact'
+
+      DATE_FORMAT = '%Y-%m-%d'
+
+      def initialize(integration = nil)
+        @integration = integration
+      end
+
+      def client(endpoint)
+        Savon.client endpoint: "#{Parsec.configuration.host}/NewAvailabilityServlet/#{RESOURCES[endpoint]}",
+                     namespace: NAMESPACE,
+                     convert_request_keys_to: :camelcase,
+                     soap_header: security_tag
+      end
+
+      def error(response)
+        { error: response[:errors][:error] }
+      end
+
+      private
+
+      def security_tag
+        {
+          'wsse:Security' => {
+            '@xmlns:wsse' => 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd',
+            'wsse:Username' => username,
+            'wsse:Password' => password,
+            'Context' => context
+          }
+        }
+      end
+
+      def username
+        @integration&.parsec_username.presence || Parsec.configuration.username
+      end
+
+      def password
+        @integration&.parsec_password.presence || Parsec.configuration.password
+      end
+
+      def context
+        Parsec.configuration.context
+      end
+
+      def logger
+        @my_logger ||= Logger.new("#{Rails.root}/log/parsec.log")
+      end
+    end
+  end
+end

data/lib/parsec/request/city.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Parsec
+  module Request
+    class City < Base
+      def by_country(country_iso_code)
+        message = { read_request: { hotel_read_request: { request_type: 'GetCities', country_code: country_iso_code } } }
+        response = client(:static_data).call('OTA_ReadRQ', message: message)
+
+        Array.wrap(response.body.dig(:ota_read_rs, :read_response, :cities, :city)).map do |c|
+          Parsec::City.new(code: c[:@city_code], name: c[:city_name], country_iso: c[:country_iso])
+        end
+      rescue Savon::Error => e
+        Xlog.and_raise_error(e)
+      end
+    end
+  end
+end

data/lib/parsec/request/country.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Parsec
+  module Request
+    class Country < Base
+      def all
+        message = { read_request: { hotel_read_request: { request_type: 'GetCountries' } } }
+        response = client(:static_data).call('OTA_ReadRQ', message: message)
+
+        response.body[:ota_read_rs][:read_response][:countries][:country] do |c|
+          Parsec::Country.new(iso: c[:country_iso], name: c[:country_name], code: c[:@country_code])
+        end
+      rescue Savon::Error => e
+        Xlog.and_raise_error(e)
+      end
+    end
+  end
+end

data/lib/parsec/request/hotel.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Parsec
+  module Request
+    class Hotel < Base
+      def details(code)
+        message = { hotel_descriptive_infos: { '@LangRequested' => 'EN', hotel_descriptive_info: { '@HotelCode' => code } } }
+        response = client(:hotel_info).call('OTA_HotelDescriptiveInfoRQ', message: message)
+
+        hotel = Parsec::Hotel.new(code: code)
+        hotel.add_details(response.body[:ota_hotel_descriptive_info_rs][:hotel_descriptive_contents][:hotel_descriptive_content])
+        hotel.add_details_with_nokogiri(response.doc)
+
+        hotel
+      rescue Savon::Error => e
+        Xlog.and_raise_error(e)
+      end
+
+      def by_country(country_iso_code)
+        hotels = hotel_search_request(ref_point: { '@CountryCode' => country_iso_code })
+        hotels.map { |h| Parsec::Hotel.build(h) }
+      end
+
+      def by_city(city_code)
+        hotels = hotel_search_request(hotel_ref: { '@HotelCityCode' => city_code })
+        hotels.map { |h| Parsec::Hotel.build(h) }
+      end
+
+      def fetch(hotel_code)
+        hotels = hotel_search_request(hotel_ref: { '@HotelCode' => hotel_code })
+        Parsec::Hotel.build(hotels.first)
+      end
+
+      private
+
+      def hotel_search_request(search_criterion)
+        message = { criteria: { criterion: search_criterion } }
+        # message = { criteria: { criterion: search_criterion.merge!('TPA_Extensions' => { return_rooms: true }) } }
+        response = client(:static_data).call('OTA_HotelSearchRQ', message: message, response_parser: :rexml)
+        Array.wrap(response.body.dig(:ota_hotel_search_rs, :properties, :property))
+      rescue Savon::Error => e
+        Xlog.and_raise_error(e)
+      end
+    end
+  end
+end

data/lib/parsec/request/location.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Parsec
+  module Request
+    class Location < Base
+      def by_city(city_code)
+        message = { read_request: { hotel_read_request: { request_type: 'GetLocations', city_code: city_code } } }
+        response = client(:static_data).call('OTA_ReadRQ', message: message)
+
+        Array.wrap(response.body.dig(:ota_read_rs, :read_response, :locations, :location)).map do |l|
+          Parsec::Location.new(code: l[:@location_code], name: l[:location_name],
+                               city_code: l[:city_code], country_iso: l[:country_iso])
+        end
+      rescue Savon::Error => e
+        Xlog.and_raise_error(e)
+      end
+    end
+  end
+end

data/lib/parsec/request/order.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Parsec
+  module Request
+    class Order < Base
+      def list(from_date, to_date, hotel_code = nil)
+        attributes = { xmlns: NAMESPACE }
+        booking_search = {
+          date_range: {
+            '@Start' => from_date.strftime(DATE_FORMAT),
+            '@End' => to_date.strftime(DATE_FORMAT),
+            '@DateType' => 'Arrival'
+          }
+        }
+        booking_search[:hotel_ref] = { '@HotelCode' => hotel_code } if hotel_code.present?
+        response = client(:list).call('OTA_BookingListRQ', attributes: attributes, message: { booking_search: booking_search })
+        return error(response.body[:ota_booking_list_rs]) if response.body[:ota_booking_list_rs][:errors].present?
+
+        response.body[:ota_booking_list_rs]
+      end
+
+      def check_booking(booking_data)
+        message = { hotel_res: { rooms: { room: rooms(booking_data) } } }
+        response = booking_request('PreBooking', message)
+        return error(response[:ota_booking_info_rs]) if response[:ota_booking_info_rs][:errors].present?
+
+        { success: response[:ota_booking_info_rs][:success] }
+      end
+
+      # booking_data = [{ booking_code1:, adults1:, children1: }, { booking_code2:, adults2:, children2: }, ...]
+      def create(booking_data, client_id, customer_text = nil)
+        message = {
+          unique_i_d: { '@Type' => 'ClientReference', '@ID' => client_id },
+          hotel_res: { rooms: { room: rooms_with_guests(booking_data, client_id) } }
+        }
+        message[:hotel_res][:special_requests] = { text: customer_text } if customer_text.present?
+        response = booking_request('Booking', message)
+        return error(response[:ota_booking_info_rs]) if response[:ota_booking_info_rs][:errors].present?
+
+        Parsec::Order.build(response[:ota_booking_info_rs])
+      end
+
+      def read(parsec_id)
+        attributes = { xmlns: NAMESPACE, 'DetailLevel' => '1', 'RateDetails' => '1', 'Language' => 'EN' }
+        message = { unique_i_d: { '@Type' => 'Locator', '@ID' => parsec_id } }
+        response = client(:read).call('OTA_ReadRQ', attributes: attributes, message: message)
+        return error(response.body[:ota_booking_info_rs]) if response.body[:ota_booking_info_rs][:errors].present?
+
+        Parsec::Order.build(response.body[:ota_booking_info_rs])
+      rescue Savon::Error => e
+        Xlog.and_raise_error(e)
+      end
+
+      def pre_cancel(parsec_id)
+        response = cancel_request('PreCancel', parsec_id)
+        return error(response[:ota_cancel_rs]) if response.dig(:ota_cancel_rs, :errors).present?
+
+        { fee_amount: response[:ota_cancel_rs][:cancel_info_rs][:cancellation_costs][:@amount].to_f }
+      end
+
+      def cancel(parsec_id)
+        response = cancel_request('Cancel', parsec_id)
+        return error(response[:ota_cancel_rs]) if response.dig(:ota_cancel_rs, :errors).present?
+
+        Parsec::Order.build(response[:ota_booking_info_rs])
+      end
+
+      private
+
+      def booking_request(type, message)
+        attributes = { xmlns: NAMESPACE, 'Transaction' => type, 'DetailLevel' => '1', 'RateDetails' => '1', 'Language' => 'EN' }
+        response = client(:reservation).call('OTA_HotelResRQ', attributes: attributes, message: message)
+        if type == 'Booking'
+          request = client(:reservation).build_request('OTA_HotelResRQ', attributes: attributes, message: message)
+          logger.info('BOOKING REQUEST') { request }
+          logger.info('BOOKING RESPONSE') { response.http.body }
+        end
+
+        response.body
+      rescue Savon::Error => e
+        Xlog.and_raise_error(e)
+      end
+
+      def cancel_request(type, parsec_id)
+        attributes = { xmlns: NAMESPACE, 'Transaction' => type }
+        message = { unique_i_d: { '@Type' => 'Locator', '@ID' => parsec_id } }
+        response = client(:cancel).call('OTA_CancelRQ', attributes: attributes, message: message)
+        if type == 'Cancel'
+          request = client(:reservation).build_request('OTA_HotelResRQ', attributes: attributes, message: message)
+          logger.info('CANCEL REQUEST') { request }
+          logger.info('CANCEL RESPONSE') { response.http.body }
+        end
+
+        response.body
+      rescue Savon::Error => e
+        Xlog.and_raise_error(e)
+      end
+
+      def rooms(booking_data)
+        booking_data.map { |data| { room_rate: { '@BookingCode' => data[:booking_code] } } }
+      end
+
+      def rooms_with_guests(booking_data, client_id)
+        rooms = booking_data.map do |data|
+          {
+            room_rate: { '@BookingCode' => data[:booking_code] },
+            guests: { guest: guests(data.slice(:adults, :children).merge(client_id: client_id)) }
+          }
+        end
+        rooms.first[:guests][:guest].first['@LeadGuest'] = 1
+
+        rooms
+      end
+
+      def guests(adults:, children: nil, client_id:)
+        pi_id = client_id.split('-').second
+        customer = ProductItem.find(pi_id).order.customer
+        guests = []
+
+        # rubocop:disable Metrics/LineLength
+        adults.to_i.times.each do
+          guests << { '@AgeCode' => 'A', person_name: { name_prefix: 'Mr.', given_name: customer.first_name, surname: customer.last_name } }
+        end
+
+        children.to_a.each do |age|
+          guests << { '@AgeCode' => 'C', '@Age' => age, person_name: { name_prefix: 'Mr.', given_name: customer.first_name, surname: customer.last_name } }
+        end
+        # rubocop:enable Metrics/LineLength
+
+        guests
+      end
+    end
+  end
+end

data/lib/parsec/request/region.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Parsec
+  module Request
+    class Region < Base
+      def by_country(country_iso_code)
+        message = { read_request: { hotel_read_request: { request_type: 'GetRegions', country_code: country_iso_code } } }
+        response = client(:static_data).call('OTA_ReadRQ', message: message)
+
+        Array.wrap(response.body.dig(:ota_read_rs, :read_response, :regions, :region)).map do |r|
+          Parsec::Region.new(code: r[:@region_code], name: r[:region_name], country_iso: r[:country_iso])
+        end
+      rescue Savon::Error => e
+        Xlog.and_raise_error(e)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: parsec_client
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mike Kniazevych
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: savon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/parsec.rb
+- lib/parsec/availability.rb
+- lib/parsec/base.rb
+- lib/parsec/city.rb
+- lib/parsec/configuration.rb
+- lib/parsec/country.rb
+- lib/parsec/hotel.rb
+- lib/parsec/location.rb
+- lib/parsec/order.rb
+- lib/parsec/region.rb
+- lib/parsec/request/availability.rb
+- lib/parsec/request/base.rb
+- lib/parsec/request/city.rb
+- lib/parsec/request/country.rb
+- lib/parsec/request/hotel.rb
+- lib/parsec/request/location.rb
+- lib/parsec/request/order.rb
+- lib/parsec/request/region.rb
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: parsec_lient cover most of functionality provided by Parsec API
+test_files: []