quicktravel_client 1.0.2

data/lib/quick_travel/location.rb

@@ -0,0 +1,14 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class Location < Adapter
+    attr_accessor :id, :name, :region_ids
+
+    self.api_base = '/locations'
+    self.lookup = true
+
+    def regions
+      Region.all.select { |r| region_ids.include?(r.id) }
+    end
+  end
+end

data/lib/quick_travel/mock.rb

@@ -0,0 +1,41 @@
+module QuickTravel
+  class Resource
+    def self.find(id)
+      new(id: id)
+    end
+
+    def product_type
+      QuickTravel::ProductType.new
+    end
+  end
+
+  class ProductType
+    def needs_passengers
+      return true if @needs_passengers.nil?
+      @needs_passengers
+    end
+  end
+
+  class PassengerType
+    def self.all
+      [
+        PassengerType.new(id: 1, name: 'Adult'),
+        PassengerType.new(id: 2, name: 'Child')
+      ]
+    end
+  end
+
+  class Adapter
+    def self.all
+      [new, new]
+    end
+  end
+
+  class PropertyType < Adapter
+    def self.all
+      [new, new]
+    end
+  end
+  class Location < Adapter; end
+  class Region < Adapter; end
+end

data/lib/quick_travel/party.rb

@@ -0,0 +1,49 @@
+module QuickTravel
+  class Party < Adapter
+    LOGIN_URL = '/login.json'
+
+    attr_accessor :id, :type, :name, :login, :title, :first_name, :last_name, :gender, :active, :internal_staff, :display_name
+
+    attr_accessor :client_id, :vendor_id
+    attr_accessor :surchargeable
+    attr_accessor :client_type_id, :client_type_name, :client_type_is_agent
+    attr_accessor :default_web_user, :rights
+
+    attr_accessor :phone, :mobile, :email   # if has a contact
+    attr_accessor :post_code, :country_id   # if has an address
+
+    def initialize(hash = {})
+      super
+      if type.blank?
+        self.type = 'Person'
+      end
+    end
+
+    self.api_base = '/parties'
+
+    def self.find_by_login(options)
+      get_and_validate('/parties/find_by_login.json', options)
+    end
+
+    # Asks QuickTravel to check the credentials
+    #
+    # @returns: Party: Valid Credentials
+    #          Nil: Invalid Credentialss
+    def self.login(options = { login: nil, password: nil })
+      fail 'You must specify :login and :password' unless options[:login] && options[:password]
+      response = post_and_validate(LOGIN_URL, options)
+      Party.new(response) unless response[:error]
+    end
+
+    def self.request_password(login, url)
+      options = { login: login, url: url }
+      post_and_validate('/sessions/request_password_reset', options)
+    end
+
+    def self.set_password_via_token(token, password)
+      post_and_validate('/sessions/set_password_via_token', token: token, password: password)
+    rescue QuickTravel::AdapterException => e
+      { error: e.message }
+    end
+  end
+end

data/lib/quick_travel/passenger.rb

@@ -0,0 +1,7 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class Passenger < Adapter
+    attr_accessor :id, :passenger_type_id, :age, :gender, :title, :first_name, :last_name, :details, :passenger_type_name
+  end
+end

data/lib/quick_travel/passenger_price_break.rb

@@ -0,0 +1,8 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class PassengerPriceBreak < Adapter
+    attr_accessor :amount_in_cents
+    money :amount
+  end
+end

data/lib/quick_travel/passenger_type.rb

@@ -0,0 +1,21 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class PassengerType < Adapter
+    attr_accessor :age_range_required, :default_age, :id, :maximum_age, :minimum_age, :name, :position, :code
+
+    self.api_base = '/passenger_types'
+    self.lookup = true
+
+    def self.passenger_counts(count_hash)
+      applicable_types = count_hash.reject { |_t, c| c.zero? }
+      applicable_types.map do |type, count|
+        pluralize(count, find(type).try(:name))
+      end
+    end
+
+    def self.pluralize(count, singular, plural = nil)
+      "#{count || 0} " + ((count == 1 || count =~ /^1(\.0+)?$/) ? singular : (plural || singular.pluralize))
+    end
+  end
+end

data/lib/quick_travel/payment.rb

@@ -0,0 +1,41 @@
+require 'quick_travel/adapter'
+require 'quick_travel/credit_card'
+
+module QuickTravel
+  class Payment < Adapter
+    attr_accessor :id, :payment_type_id, :amount_in_cents, :authorization, :success, :created_at
+    money :amount
+
+    def payment_type
+      QuickTravel::PaymentType.find(@payment_type_id)
+    end
+
+    def self.create(options = {})
+      post_and_validate("/front_office/bookings/#{options[:booking_id]}/payments.json", options)
+    end
+
+    def self.charge_account(booking, payment_options = {})
+      payment_type = booking.on_account_payment_type
+
+      if payment_type.nil?
+        fail ArgumentError, 'Booking not allowed to be paid on account'
+      end
+
+      agent_booking_reference = payment_options[:agent_booking_reference]
+      amount                  = payment_options[:amount].presence
+
+      options = {
+        payment: {
+          payment_type_id:   payment_type.id,
+          uid:               SecureRandom.hex(16),
+          comment:           agent_booking_reference,
+          amount:            amount,
+          currency_iso_code: 'AUD'
+        },
+        pay_balance: amount.nil?
+      }
+
+      post_and_validate("/api/bookings/#{booking.id}/payments.json", options)
+    end
+  end
+end

data/lib/quick_travel/payment_type.rb

@@ -0,0 +1,37 @@
+require 'quick_travel/adapter'
+require 'quick_travel/cache'
+
+module QuickTravel
+  class PaymentType < Adapter
+    attr_accessor :id,
+                  :name,
+                  :description,
+                  :position,
+                  :active,
+                  :payment_method,
+                  :for_frequent_traveller_redemption,
+                  :notes,
+                  :surchargeable,
+                  :transaction_fee,
+                  :credit_card_brand
+
+    self.api_base = '/payment_types'
+    self.lookup = true
+
+    def credit_card
+      payment_method == 'credit_card'
+    end
+
+    def code
+      if credit_card
+        credit_card_brand.underscore.gsub(/\s/, '_')
+      else
+        payment_method
+      end
+    end
+
+    def as_json(options = nil)
+      super.merge(code: code)
+    end
+  end
+end

data/lib/quick_travel/price.rb

@@ -0,0 +1,14 @@
+class Price
+  attr_accessor :cents, :currency, :dollars
+
+  def initialize(hash)
+    cents = hash['cents'].to_i
+    @dollars = cents / 100
+    @cents = cents % 100
+    @currency = hash['currency']
+  end
+
+  def formatted_text
+    "#{@dollars}"
+  end
+end

data/lib/quick_travel/product.rb

@@ -0,0 +1,165 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class Product < Adapter
+    attr_accessor :selection_name,
+                  :description,
+                  :capacity,
+                  :available_capacity,
+                  :available,
+                  :error_message
+
+    attr_accessor :price # money_json(bookable_product.price)
+
+    attr_accessor :reservation_attributes
+    attr_accessor :image # is it url?  dunno  =>  json.image bookable_product.image
+    # {url: image_url, desc: image_desc}
+
+    attr_accessor :is_assigned # is it an assigned product -- i.e. reserved...
+    # useful only for extras when going through reservations api
+
+    attr_accessor :extras # more products
+
+    self.api_base = '/api/products'
+
+    # Find product details for a given product
+    #
+    # Options are::tabnew
+    #   passenger_types: {<passenger_type_id> => <num_pax>, ...},
+    #   date_range: {start_date: <date>, end_date: <date>}
+    def self.find(id, params = {})
+      fail 'Product#find requires passenger_type_numbers' if params[:passenger_type_numbers].blank?
+      fail 'Product#find requires date_range' if params[:date_range].blank?
+      super
+    end
+
+    def self.bulk_availability(resource_ids, date_from, date_to, units)
+      request_params = {
+        resource_ids: resource_ids,
+        date_from:    date_from,
+        date_to:      date_to,
+        units:        units
+      }
+      get_and_validate('/api/availability/bulk.json', request_params)
+    end
+
+    def self.unavailable_dates(resource_ids, date_from, date_to)
+      request_params = {
+        resource_ids: resource_ids,
+        date_from:    date_from,
+        date_to:      date_to
+      }
+      get_and_validate('/api/availability/unavailable_dates.json', request_params)
+    end
+
+    # Returns minified mega structure:
+    #
+    # products_by_resource_id_and_date
+    # {
+    #   <resource-id> => {<date> => <product-instance>, ...},
+    #   ...
+    # }
+    def self.fetch_and_arrange_by_resource_id_and_date(resource_ids, options = {})
+      request_params = options.clone
+      request_params[:resource_ids] = resource_ids
+
+      # Returned call mega-structure is:
+      # [
+      #   {
+      #     "resource" => {"id" => <resource-id>, "name" => <resource-name>},
+      #     "bookability" => {
+      #       <date-as-string>  => {<product-attrs}
+      #       ...
+      #     }
+      #   },
+      #   ...
+      # ]
+      complex_data = get_and_validate('/api/products/date_range_bookability.json', request_params)
+      complex_data ||= {}
+
+      products_by_resource_id_and_date = {}
+
+      # Go through shitty complex_grid_data
+      complex_data.each do |resource_and_bookability_hash|
+        resource_id = resource_and_bookability_hash.fetch('resource', {}).fetch('id', nil)
+        product_attrs_by_date = resource_and_bookability_hash.fetch('bookability', {})
+
+        products_by_resource_id_and_date[resource_id] = {}
+        product_attrs_by_date.each do |date, product_attrs|
+          products_by_resource_id_and_date[resource_id][date] = new(product_attrs)
+        end
+      end
+
+      products_by_resource_id_and_date
+    end
+
+    attr_accessor :availability_details
+    attr_accessor :pricing_details,
+                  :pricing_details_for_rack_rate,
+                  :pricing_details_without_rules
+
+    def id
+      @reservation_attributes['resource_id']
+    end
+
+    def name
+      @selection_name
+    end
+
+    def available?
+      !!@available
+    end
+
+    def extras=(extra_attrs)
+      @extras = extra_attrs.map do |extra_attr|
+        QuickTravel::Product.new(extra_attr)
+      end
+    end
+
+    def select_extras_by_id(selected_ids)
+      @extras.select { |extra| selected_ids.include? extra.id }
+    end
+
+    def resource=(resource_hash)
+      @resource = QuickTravel::Resource.new(resource_hash)
+    end
+
+    def availability_details=(availability_details)
+      @availability_details = AvailabilityDetails.new(availability_details)
+    end
+
+    def pricing_details=(pricing_details)
+      @pricing_details = PricingDetails.new(pricing_details)
+    end
+
+    def pricing_details_for_rack_rate=(pricing_details_for_rack_rate)
+      @pricing_details_for_rack_rate = PricingDetails.new(pricing_details_for_rack_rate)
+    end
+
+    def pricing_details_without_rules=(pricing_details_without_rules)
+      @pricing_details_without_rules = PricingDetails.new(pricing_details_without_rules)
+    end
+  end
+
+  class PricingDetails < Adapter
+    attr_accessor :minimum_price_in_cents, :minimum_price_with_adjustments_in_cents, :total_adjustments_in_cents
+    attr_accessor :price_per_pax_type, :adjustments_to_apply, :applied_rules
+
+    money :minimum_price, :minimum_price_with_adjustments, :total_adjustments
+
+    def price_per_pax_type=(pax_type_hash)
+      @price_per_pax_type = convert_pax_type_hash(pax_type_hash)
+    end
+
+    def convert_pax_type_hash(pax_type_hash)
+      pax_type_hash.each.with_object({}) { |(type, cents), hash| hash[type.to_i] = Money.new(cents.to_i) }
+    end
+  end
+
+  class AvailabilityDetails < Adapter
+  end
+
+  class PricePerPaxType < Adapter
+    attr_accessor :amount_in_cents
+  end
+end

data/lib/quick_travel/product_configuration.rb

@@ -0,0 +1,134 @@
+require 'quick_travel/adapter'
+require 'set'
+
+module QuickTravel
+  class ProductConfiguration
+    attr_reader :product, :extra_pick_configurations
+    delegate :id, :name, to: :product
+
+    def initialize(product)
+      @product = product
+      @selected = false
+      @extra_pick_configurations =
+        product.extras.map { |extra_pick| self.class.new(extra_pick) }
+    end
+
+    def select!
+      @selected = true
+    end
+
+    def deselect!
+      @selected = false
+    end
+
+    def selected?
+      @selected
+    end
+
+    def available?
+      @product.available? &&
+        selected_extra_pick_configurations.all?(&:available?)
+    end
+
+    def priced?
+      @product.pricing_details.present?
+    end
+
+    def price
+      pricing_details.minimum_price_with_adjustments
+    end
+
+    def price_without_rules
+      pricing_details_without_rules.minimum_price_with_adjustments
+    end
+
+    def price_for_rack_rate
+      pricing_details_for_rack_rate.minimum_price_with_adjustments
+    end
+
+    def total_price
+      price + selected_extra_picks_price
+    end
+
+    def total_price_without_rules
+      price_without_rules + selected_extra_picks_price_without_rules
+    end
+
+    def total_price_for_rack_rate
+      price_for_rack_rate + selected_extra_picks_price_for_rack_rate
+    end
+
+    def applied_rules
+      pricing_details.applied_rules.uniq
+    end
+
+    def total_applied_rules
+      (applied_rules + selected_extra_picks_applied_rules).uniq
+    end
+
+    def price_per_passenger_type(passenger_type_id)
+      pricing_details.price_per_pax_type[passenger_type_id]
+    end
+
+    def selected_extra_pick_configurations
+      @extra_pick_configurations.select(&:selected?)
+    end
+
+    def available_extra_pick_configurations
+      @extra_pick_configurations.select(&:available?)
+    end
+
+    def select_extra_picks(extra_picks)
+      extra_picks.each do |extra_pick|
+        select_extra_pick(extra_pick)
+      end
+    end
+
+    def select_extra_pick(extra_pick)
+      extra_pick_configuration = configuration_for(extra_pick)
+
+      if extra_pick_configuration.nil?
+        fail ArgumentError, 'That extra pick does not belong to the product'
+      end
+
+      extra_pick_configuration.select!
+    end
+
+    private
+
+    def configuration_for(extra_pick)
+      @extra_pick_configurations.find do |extra_pick_configuration|
+        extra_pick_configuration.product == extra_pick
+      end
+    end
+
+    def selected_extra_picks_price
+      selected_extra_pick_configurations.map(&:price).total_money
+    end
+
+    def selected_extra_picks_price_without_rules
+      selected_extra_pick_configurations.map(&:price_without_rules).total_money
+    end
+
+    def selected_extra_picks_price_for_rack_rate
+      selected_extra_pick_configurations.map(&:price_for_rack_rate).total_money
+    end
+
+    def selected_extra_picks_applied_rules
+      selected_extra_pick_configurations.flat_map(&:applied_rules)
+    end
+
+    def pricing_details
+      fail 'Unable to calculate pricing details' unless priced?
+      @product.pricing_details
+    end
+
+    def pricing_details_without_rules
+      @product.pricing_details_without_rules || pricing_details
+    end
+
+    def pricing_details_for_rack_rate
+      @product.pricing_details_for_rack_rate || pricing_details
+    end
+  end
+end

data/lib/quick_travel/product_passenger_search_criteria.rb

@@ -0,0 +1,28 @@
+module QuickTravel
+  class ProductPassengerSearchCriteria
+    def self.from_passengers(passengers)
+      new.tap do |product_passenger_search_criteria|
+        passengers.each do |passenger|
+          product_passenger_search_criteria.add_passenger_of_type(passenger.passenger_type_id)
+        end
+      end
+    end
+
+    def initialize
+      @passenger_count_by_type = {}
+    end
+
+    def add_passenger_of_type(passenger_type_id)
+      @passenger_count_by_type[passenger_type_id] ||= 0
+      @passenger_count_by_type[passenger_type_id] += 1
+    end
+
+    def set_count_for_passenger_type(passenger_type_id, count)
+      @passenger_count_by_type[passenger_type_id] = count
+    end
+
+    def to_hash
+      @passenger_count_by_type
+    end
+  end
+end

data/lib/quick_travel/product_type.rb

@@ -0,0 +1,28 @@
+module QuickTravel
+  class ProductType < Adapter
+    attr_accessor :book_before_level, :book_before_units, :bookable_online, :can_find_by_location, :confirmation_request_fields, :default_passenger_ticket_format_id, :default_reservation_ticket_format_id
+    attr_accessor :default_vehicle_ticket_format_id, :detailed_template_fields, :disclaimer_id, :durational, :id, :individual_tickets
+    attr_accessor :individual_tickets, :mark_up_cents, :mark_up_definition_id, :mark_up_percent, :mark_up_rack_from_cost, :mark_up_rounding_cents
+    attr_accessor :mark_up_rounding_direction, :maximum_passengers_online, :measure_units_by_pax_count, :multi_leg, :name, :no_ticket
+    attr_accessor :only_bookable_with_accommodation, :overview_template_fields, :prompt_for_pick_up_drop_off, :resource_class_name, :rule_set_id,
+                  :can_have_dates,
+                  :can_have_quantity,
+                  :needs_passengers
+
+    self.api_base = '/product_types'
+
+    def self.all
+      QuickTravel::Cache.cache 'all_product_types' do
+        super
+      end
+    end
+
+    def route
+      Route.first(id)
+    end
+
+    def routes
+      Route.all(id)
+    end
+  end
+end

data/lib/quick_travel/property.rb

@@ -0,0 +1,99 @@
+require 'quick_travel/adapter'
+require 'quick_travel/property_facility'
+
+module QuickTravel
+  class Property < Adapter
+    attr_accessor :id, :name,  :check_in, :check_in_instructions, :check_out, :contact_id, :contact_person, :description
+    attr_accessor :location_id, :notes, :star_rating, :tourism_accredited, :availability, :on_request
+    attr_accessor :minimum_available_price_in_cents
+    attr_accessor :graphic # required in property search object
+    attr_accessor :boundary_start, :boundary_end, :season_id # added in API 3.8.*
+    attr_accessor :minimum_bookable_duration
+    attr_accessor :maximum_occupancy
+    attr_accessor :location_name, :region_names, :error
+
+    attr_reader :accommodations
+
+    money :minimum_available_price
+
+    def accommodations=(hash_array)
+      @accommodations = hash_array.map { |accommodation_hash| Accommodation.new(accommodation_hash) }
+    end
+
+    # This method returns first object of Property based on property id from QuickTravel
+    def self.first(id, options = {})
+      fail ArgumentError.new('Must Specify valid property id') if id.blank? || id.class != Fixnum
+      generic_first("/api/properties/#{id}.json", options)
+    end
+
+    # This method returns all objects of property from QuickTravel that match
+    #
+    # location_id is compulsory param
+    # :property_type_id=>1, :location_id=>5
+    #
+    # Example response:
+    #   { :property_type_id=>1, :location_id=>5  , :number_of_rooms => 1 ,  :product => {:first_travel_date => "07-05-2010" , :duration => 1 } }
+    def self.find!(condition = {})
+      condition[:number_of_rooms] = 1 if condition[:number_of_rooms].blank? ||  condition[:number_of_rooms].to_i < 1
+      condition[:last_travel_date] = condition[:product][:last_travel_date].to_date - 1 if condition[:product].try(:fetch, :last_travel_date, nil)
+      self.find_all!('/api/properties.json', condition)
+    end
+
+    def self.load_with_pricing(id, options)
+      # Find property 'standard' way -- finds price for whole duration
+      property = Property.first(id, options)
+      first_travel_date = options[:product][:first_travel_date]
+      property.accommodations.each do |accommodation|
+        accommodation.minimum_nightly_price      = accommodation.nightly_price_on first_travel_date
+        accommodation.minimum_price_for_duration = accommodation.minimum_price_on first_travel_date
+      end
+
+      property
+    end
+
+    def to_param
+      "#{id}-#{name.gsub(' ', '-')}"
+    end
+
+    def self.all!
+      self.find_all!('/properties.json')
+    end
+
+    # this method is only used for properties that are searched through find method, because QT_API returns graphic string in search results
+    def graphic_url
+      QuickTravel.url + graphic if graphic.present?
+    end
+
+    def graphics=(graphics)
+      @graphic_attributes = graphics
+    end
+
+    def graphics
+      @graphics ||= @graphic_attributes.map { |g| QuickTravel::Graphic.new(g) }
+    end
+
+    def accommodations_by_availability(stay_dates)
+      accommodations.sort_by do |accommodation|
+        (accommodation.available_over_dates?(stay_dates) ? 0 : 1)
+      end
+    end
+
+    def check_availability(date)
+      availability && availability[date.to_s]
+    end
+
+    def available?
+      # self.availability.present? &&
+      # self.availability.any?{|availability_level| availability_level == 'on_allotment_and_available' }
+      availability.present? && availability.all? { |_date, is_avail| is_avail }
+    end
+
+    def property_facilities
+      @_property_facilities ||= @property_facilities.map { |item| PropertyFacility.new(item) }
+    end
+
+    def address
+      @_address ||= Address.new(@address)
+    end
+  end
+end