quicktravel_client 1.0.2

data/lib/quick_travel/booking.rb

@@ -0,0 +1,370 @@
+require 'quick_travel/adapter'
+require 'quick_travel/passenger'
+require 'quick_travel/vehicle'
+require 'quick_travel/payment'
+require 'quick_travel/payment_type'
+require 'quick_travel/discounts'
+
+module QuickTravel
+  class Booking < Adapter
+    attr_accessor :reference, :state, :client_id, :first_travel_date, :created_at, :access_token
+    attr_accessor :gross_in_cents, :commission_in_cents, :cost_in_cents, :balance_in_cents, :paid_in_cents, :surcharge_in_cents
+    attr_accessor :deposit_in_cents, :deposit_due_on, :deposit_relevant
+
+    attr_accessor :id # booking_id. I am initializing this data member when we create booking.
+    attr_accessor :client_address, :client_party, :client_contact,
+                  :customer_contact_name, :customer_contact_phone, :customer_contact_mobile, :customer_contact_email,
+                  :post_code, :country_id, :referral_code_id,
+                  :discardable_in, :inactivatable_in,
+                  :promo_code, :web_site_name,
+                  :insurance_offered, :public_comments
+
+    money :gross, :balance, :commission, :paid, :surcharge, :deposit
+
+    def self.api_base
+      '/api/bookings'
+    end
+
+    def self.front_office_base
+      '/front_office/bookings'
+    end
+
+    def self.find_by_reference(reference)
+      find_all!("#{api_base}/reference/#{reference}.json").first
+    end
+
+    def documents(regenerate = false)
+      Document.find_all!("#{Booking.api_base}/#{@id}/documents.json",
+                         last_group: true, regenerate: regenerate)
+    end
+
+    def payments
+      Payment.find_all!("#{Booking.front_office_base}/#{@id}/payments.json")
+    end
+
+    def payment_types
+      PaymentType.find_all!("#{Booking.front_office_base}/#{@id}/payment_types.json")
+    end
+
+    def on_account_payment_type
+      payment_types_by_code = payment_types.group_by(&:code)
+
+      # Try on-account, or if not, on-account-with-reference
+      payment_types_by_code['on_account_without_reference'].try(:first) ||
+        payment_types_by_code['on_account_with_reference'].try(:first)
+    end
+
+    def country
+      Country.find(@country_id)
+    end
+
+    def deposit_due_on
+      @deposit_due_on_parsed ||= parse_date(@deposit_due_on)
+    end
+
+    def balance_due_on
+      @balance_due_on_parsed ||= parse_date(@balance_due_on)
+    end
+
+    # Create an empty booking
+    #
+    # Note, options pertain to initializing booking with some values:
+    #
+    # options = {
+    #  :when => "28-04-2010" ,
+    #  :passengers => { "1" => nil, "2" => nil, "3" => nil, "4" => nil , "5" => nil } ,
+    #  :include_vehicle => nil , :vehicle => { :vehicle_type_id => nil , :length , :weight  } ,
+    #  :vehicle_return_weight  => nil ,
+    #  :include_trailer  => nil ,
+    #  :trailer => { :vehicle_type_id => nil , :length => nil  }
+    # }
+    def self.create(options = {})
+      default_options = { referral_code_id: DEFAULT_REFERRAL_CODE_ID }
+      options = { booking: default_options.merge(options) }
+
+      response = post_and_validate("#{front_office_base}.json", options)
+      fail AdapterException.new(response) unless response['id']
+
+      return nil unless response['id']
+      Booking.new(response)
+    end
+
+    # Update an existing booking
+    def update(options = {})
+      response = put_and_validate("#{api_base}/#{@id}.json", booking: options)
+      # id is returned if other attributes change otherwise success: true
+      fail AdapterException.new(response) unless response['id'] || response['success']
+
+      Booking.find(@id)
+    end
+
+    # ###
+    # Updates:
+    #   - Client information
+    #   - Client contact
+    #   - Client address
+    #   - Pax details
+    #   - Vehicle details
+    def update_with_nested_attributes!(booking_args = {})
+      response = put_and_validate("#{api_base}/#{@id}/update_with_nested_attributes.json",
+                                  booking: booking_args)
+      fail AdapterException.new(response) unless response['id']
+      Booking.find(response['id'])
+    end
+
+    def remove_unassigned_passengers
+      put_and_validate("/api/bookings/#{@id}/remove_unassigned_passengers")
+    end
+
+    # Create an accommodation reservation from the given options
+    #
+    # Returns current booking object after having added the reservation
+    #
+    # reservations_options = {
+    #   :id => nil ,
+    #   :first_travel_date => nil,
+    #   :last_travel_date => nil,
+    #   :resource_id => nil ,
+    #   :passenger_ids => {} ,
+    #   :vehicle_ids => {} ,
+    #   :bed_configuration_id => nil ,
+    #   :tariff_level_id => nil
+    # }
+    #
+    # Example 2:
+    # reservations_options = {
+    #   :first_trave_date => "28-04-2010",
+    #   :last_travel_date => "28-04-2010",
+    #   :resource_id => 89,
+    #   :bed_configuration_id => 581,
+    #   :passenger_ids => {""=>nil},
+    #   :vehicle_ids => {""=>nil}
+    # }
+    def accommodation_reserve(reservations_options = {})
+      if reservations_options[:last_travel_date].nil?
+        fail AdapterException.new('No checkout date specified')
+      end
+
+      last_travel_date = Date.strptime(reservations_options[:last_travel_date], '%d/%m/%Y')
+
+      # Because QT requires last-date to be the date of use, we have to subtract one
+      last_travel_date -= 1
+
+      options = { reservations: reservations_options }
+      options[:reservations][:last_travel_date] = last_travel_date.strftime(QT_DATE_FORMAT)
+
+      reserve('accommodations/create_or_update', options)
+    end
+
+    # Reserve a scheduled trips resource
+    # Returns current booking object after having added the reservation
+    #
+    # Note:
+    # Forward_options and return_options look similar, but each is a different trip
+    #
+    # Example:
+    # forward_options = {
+    #   :passenger_ids => {} ,
+    #   :vehicle_ids => {} ,
+    #   :first_travel_date => nil,
+    #   :tariff_level_id => nil ,
+    #   :resource_id => nil ,
+    #   :trip_id => nil
+    # }
+    def scheduled_trips_reserve(segments = {})
+      reserve(:scheduled_trips, segments.merge(segments: segments.keys))
+    end
+
+    def scheduled_trips_update(segments = {})
+      params = segments.merge(segments: segments.keys)
+      params[:booking_id] = @id
+      put_and_validate('/reservation_for/scheduled_trips/bulk_update.json', params)
+      Booking.find(@id)
+    end
+
+    def generics_reserve(options)
+      reserve(:generics, options)
+    end
+
+    def item_reserve(options)
+      reserve(:items, options)
+    end
+
+    def tour_reserve(options)
+      reserve(:packages, options)
+    end
+
+    # Delete a reservation
+    #
+    # Returns current booking object after deleting the reservation
+    def delete_reservation(reservation)
+      delete_reservation_by_id(reservation.id)
+    end
+
+    def delete_reservation_by_id(reservation_id)
+      if state != 'new'
+        fail AdapterException.new('Reservation cannot be deleted unless the booking is new')
+      end
+
+      delete_and_validate("#{api_base}/#{@id}/reservations/#{reservation_id}.json")
+      refresh!
+    end
+
+    def refresh!
+      Booking.find(@id)  # refresh
+    end
+
+    # Generate passenger objects from passenger data (hash)
+    def passengers
+      @passengers ||=
+        @passengers_attributes.map { |passenger| Passenger.new(passenger) }
+    end
+
+    # Generate passenger objects from passenger data (hash)
+    def vehicles
+      @vehicles ||=
+        @vehicles_attributes.map { |vehicle| Vehicle.new(vehicle) }
+    end
+
+    def find_passenger_by_id(pid)
+      passengers.detect { |p| p.id.to_i == pid.to_i }
+    end
+
+    def find_vehicle_by_id(vid)
+      vehicles.detect { |v| v.id.to_i == vid.to_i }
+    end
+
+    def passenger_types_counts
+      passengers.each_with_object(Hash.new(0)) do |passenger, hash|
+        hash[passenger.passenger_type_id] += 1
+      end
+    end
+
+    def vehicles_hash
+      @vehicles
+    end
+
+    # It returns booking items for a booking.
+    # Array of BookingItem
+    def reservations
+      fail AdapterException, 'Reservations have not been set from API' if @reservations_attributes.nil?
+      @_reservations_object_array ||= @reservations_attributes.map { |item| Reservation.new(item) }
+    end
+
+    def legacy_reservations
+      @_reservations_object_array = @reservations.map { |item| Reservation.new(item) }
+    end
+
+    def client_address
+      @client_address_object ||= Address.new(@client_address)
+    end
+
+    def client_party
+      @client_party_object ||= Party.new(@client_party)
+    end
+
+    def client_contact
+      @client_contact_object ||= Contact.new(@client_contact)
+    end
+
+    def client
+      @client_object ||= Client.new(@client)
+    end
+
+    def calculate_existing_and_new_vehicles_for(required_vehicle_types)
+      return [[], []] if required_vehicle_types.blank?
+
+      vehicle_types_to_add = []
+      existing_vehicle_ids_to_assign = []
+
+      vehicles_yet_to_include = try(:vehicles)
+
+      required_vehicle_types.each do |searched_vehicle_type_hash|
+        matching_existing_vehicle = vehicles_yet_to_include.detect { |veh| veh.vehicle_type_id.to_i == searched_vehicle_type_hash[:vehicle_type_id].to_i }
+        if matching_existing_vehicle
+          existing_vehicle_ids_to_assign << matching_existing_vehicle.id.to_i
+          vehicles_yet_to_include -= [matching_existing_vehicle]
+
+        else
+          vehicle_types_to_add << searched_vehicle_type_hash
+        end
+      end
+
+      [existing_vehicle_ids_to_assign, vehicle_types_to_add]
+    end
+
+    def include_reservation_of?(product_type_id)
+      reservations.any? { |r| r.product_type_id.to_i == product_type_id }
+    end
+
+    def includes_resource_class?(resource_class_name)
+      reservations.any? { |r| r.resource_class_name == resource_class_name }
+    end
+
+    def clear_unfinished_reservations!
+      booking = self
+      reservations.reject(&:complete).each do |reservation|
+        # This will return updated booking..
+        booking = delete_reservation(reservation)
+      end
+      booking
+    end
+
+    def finalised?
+      (balance_in_cents == 0 && state != 'new' && !reservations.empty?) || state == 'quote'
+    end
+
+    def discount
+      @discount ||= fetch_discount
+    end
+
+    def discount_on(reservation)
+      discount.discount_on(reservation.id)
+    end
+
+    def total_discount_on(reservation)
+      discount.total_discount_on(reservation.id)
+    end
+
+    def calculate_price_quote(segments = {})
+      params = segments.merge(segments: segments.keys)
+      response = post_and_validate("#{api_base}/#{@id}/price_quotes/calculate", params)
+      Money.new(response['quoted_booking_gross_in_cents'])
+    end
+
+    def activate!
+      put_and_validate("#{api_base}/#{@id}/activate")
+    end
+
+    def subscribe_to_email_list(email = nil)
+      params = email.nil? ? {} : { email: email }
+      put_and_validate("#{api_base}/#{@id}/subscribe_to_email_list", params)
+    end
+
+    # secureAccessCodeString is simply a MAC algorithm (using SHA1) on the booking id string.
+    # it is using @id that is booking.id and configuration constant QUICK_TRAVEL_ACCESS_KEY
+    def secure_access_code
+      Encrypt.access_key(@id.to_s)
+    end
+
+    protected
+
+    def reserve(url, options)
+      options[:booking_id] = @id
+      post_and_validate("/reservation_for/#{url}.json", options)
+      Booking.find(@id)
+    end
+
+    private
+
+    def parse_date(hash)
+      return if hash.blank? || hash['_value'].blank?
+      hash['_value'].to_date
+    end
+
+    def fetch_discount
+      attributes = get_and_validate("#{api_base}/#{@id}/discount.json")
+      QuickTravel::Discounts::BookingDiscount.new(attributes)
+    end
+  end
+end

data/lib/quick_travel/cache.rb

@@ -0,0 +1,38 @@
+module QuickTravel
+  module Cache
+    def cache(key, &block)
+      QuickTravel::Cache.cache(key) do
+        block.call
+      end
+    end
+
+    def self.cache(key)
+      cached_value = cache_store.read(key)
+      return cached_value unless cached_value.nil?
+      return nil unless block_given?
+      yield.tap { |value| cache_store.write(key, value) }
+    end
+
+    def self.cache_store
+      @@cache_store
+    end
+
+    def self.cache_store=(store)
+      @@cache_store = store
+    end
+  end
+
+  class DefaultCacheStore
+    def initialize
+      @store = {}
+    end
+
+    def write(key, value)
+      @store[key] = value
+    end
+
+    def read(key)
+      @store[key]
+    end
+  end
+end

data/lib/quick_travel/client.rb

@@ -0,0 +1,8 @@
+module QuickTravel
+  class Client < Adapter
+    attr_accessor :id, :party_id, :surchargeless, :client_type,
+                  :contact_phone, :contact_mobile, :contact_email,
+                  :name,
+                  :first_name, :last_name
+  end
+end

data/lib/quick_travel/client_type.rb

@@ -0,0 +1,6 @@
+module QuickTravel
+  class ClientType < Adapter
+    attr_accessor :id, :name, :agent, :position, :right_id
+    self.api_base = '/client_types'
+  end
+end

data/lib/quick_travel/config.rb

@@ -0,0 +1,26 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class Configuration
+    attr_accessor :url, :access_key, :version
+
+    def url=(url)
+      @url = url
+      QuickTravel::Adapter.base_uri url
+    end
+
+    attr_writer :access_key
+  end
+
+  def self.configure
+    yield QuickTravel.config
+  end
+
+  def self.config
+    @config ||= QuickTravel::Configuration.new
+  end
+
+  def self.url
+    config.url
+  end
+end

data/lib/quick_travel/connection_error.rb

@@ -0,0 +1,9 @@
+module QuickTravel
+  class ConnectionError < Exception
+    attr_reader :original
+    def initialize(msg, original = $ERROR_INFO)
+      super(msg)
+      @original = original
+    end
+  end
+end

data/lib/quick_travel/constants.rb

@@ -0,0 +1,16 @@
+### DELETE ME!  Left here only so you can pull out the constants for the few that we should be keeping.
+
+module QuickTravel
+  LOGIN_URL  = '/parties/login' # CMS_SSL_URL + '/parties/login'
+
+  DEFAULT_LOCATION_ID_FOR_ACCOMM_SEARCH = 3 # Kingscote
+  DEFAULT_REGION_ID_FOR_ACCOMM_SEARCH = 1   # Kangaroo Island
+  DEFAULT_PROPERTY_TYPE_ID_FOR_ACCOMM_SEARCH = 1
+
+  # System wide
+  PROPERTY_CACHE_TIMEOUT = 1440 # minutes
+  AUSTRALIA_COUNTRY_ID = 14
+  QT_DATE_FORMAT = '%d-%m-%Y'
+
+  DEFAULT_REFERRAL_CODE_ID = 33
+end

data/lib/quick_travel/contact.rb

@@ -0,0 +1,5 @@
+module QuickTravel
+  class Contact < Adapter
+    attr_accessor :phone, :email, :id
+  end
+end

data/lib/quick_travel/country.rb

@@ -0,0 +1,11 @@
+require 'quick_travel/adapter'
+require 'quick_travel/cache'
+
+module QuickTravel
+  class Country < Adapter
+    attr_accessor :id, :iso_3166_code, :name, :latitude, :longitude
+
+    self.api_base = '/api/countries'
+    self.lookup = true
+  end
+end

data/lib/quick_travel/credit_card.rb

@@ -0,0 +1,12 @@
+module QuickTravel
+  class CreditCard
+    def self.type_from_number(number)
+      case number.to_s
+      when /^4.*$/ then 'visa'
+      when /^5[1-5].*$/ then 'master'
+      when /^3[4,7].*$/ then 'american_express'
+      when /^3[0,6,8].*$/ then 'diners_club'
+      end
+    end
+  end
+end

data/lib/quick_travel/discounts/booking_discount.rb

@@ -0,0 +1,18 @@
+module QuickTravel
+  module Discounts
+    class BookingDiscount < DiscountTree
+      def initialize(attrs = {})
+        super(
+          attrs.merge(
+            'root'     => attrs,
+            'children' => attrs['reservation_discounts']
+          )
+        )
+      end
+
+      def reservation_discounts
+        @children
+      end
+    end
+  end
+end

data/lib/quick_travel/discounts/discount.rb

@@ -0,0 +1,21 @@
+module QuickTravel
+  module Discounts
+    class Discount
+      attr_reader :target
+      attr_reader :original_price, :discounted_price, :discount, :reason
+
+      def initialize(attrs = {})
+        @target = OpenStruct.new(attrs.fetch('target').slice('id', 'type'))
+
+        @original_price   = Money.new(attrs.fetch('original_price_in_cents'))
+        @discounted_price = Money.new(attrs.fetch('discounted_price_in_cents'))
+        @discount         = Money.new(attrs.fetch('discount_in_cents'))
+        @reason           = attrs.fetch('reason')
+      end
+
+      def applied_on?(id, type = 'Reservation')
+        @target.type == type && @target.id == id
+      end
+    end
+  end
+end

data/lib/quick_travel/discounts/discount_tree.rb

@@ -0,0 +1,35 @@
+module QuickTravel
+  module Discounts
+    class DiscountTree < Discount
+      attr_reader :root, :children
+
+      def initialize(attrs = {})
+        super(attrs)
+        @root     = Discount.new(attrs['root'])
+        @children = attrs.fetch('children', []).map do |child_attrs|
+          DiscountTree.new(child_attrs)
+        end
+      end
+
+      def discount_on(id, type = 'Reservation')
+        return @root if applied_on?(id, type)
+        find_and_return_on_children { |child| child.discount_on(id, type) }
+      end
+
+      def total_discount_on(id, type = 'Reservation')
+        return self if applied_on?(id, type)
+        find_and_return_on_children { |child| child.total_discount_on(id, type) }
+      end
+
+      private
+
+      def find_and_return_on_children(&block)
+        @children.each do |child|
+          result = block.call(child)
+          return result unless result.nil?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/quick_travel/discounts.rb

@@ -0,0 +1,3 @@
+require 'quick_travel/discounts/discount'
+require 'quick_travel/discounts/discount_tree'
+require 'quick_travel/discounts/booking_discount'

data/lib/quick_travel/document.rb

@@ -0,0 +1,20 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class Document < Adapter
+    attr_accessor :id, :booking_id, :name
+
+    self.api_base = "/front_office/bookings/#{@booking_id}/documents"
+
+    # We used to direct the browser to QT directly
+    # Now, we proxy over to it, and return the data
+    # def pdf_url
+    # #"#{QuickTravel.config.url}/api/bookings/#{@booking_id}/documents/#{@id}.pdf?key=#{access_key("document:#{@id}")}"
+    # end
+
+    # Do a second request fetching the PDF
+    def fetch_pdf
+      get_and_validate "/api/bookings/#{@booking_id}/documents/#{@id}.pdf"
+    end
+  end
+end

data/lib/quick_travel/document_group.rb

@@ -0,0 +1,14 @@
+require 'quick_travel/adapter'
+require 'quick_travel/encrypt'
+
+module QuickTravel
+  class DocumentGroup < Adapter
+    attr_accessor :id, :booking_id
+
+    self.api_base = "/front_office/bookings/#{@booking_id}/document_groups"
+
+    def pdf_url
+      "#{QuickTravel.config.url}/api/bookings/#{@booking_id}/document_groups/#{@id}.pdf?key=#{Encrypt.access_key("document_group:#{@id}")}"
+    end
+  end
+end

data/lib/quick_travel/encrypt.rb

@@ -0,0 +1,13 @@
+require 'openssl'
+require 'base64'
+
+DIGEST = OpenSSL::Digest.new('sha256')
+
+module QuickTravel
+  module Encrypt
+    def self.access_key(text)
+      digest = OpenSSL::HMAC.hexdigest(DIGEST, QuickTravel.config.access_key, text)
+      Base64.encode64s(digest).chomp
+    end
+  end
+end

data/lib/quick_travel/graphic.rb

@@ -0,0 +1,18 @@
+module QuickTravel
+  class Graphic
+    attr_accessor :thumbnails, :image_uid
+
+    def initialize(g)
+      @image_uid = g['image_uid']
+    end
+
+    def path(thumbnail_name)
+      result = @thumbnails.find_all { |t| t['thumbnail'] == thumbnail_name.to_s }
+      '/media/cache/' + result.first['filename'] unless result.blank?
+    end
+
+    def url(thumbnail_name)
+      QuickTravel.url + path(thumbnail_name)
+    end
+  end
+end

data/lib/quick_travel/init_from_hash.rb

@@ -0,0 +1,16 @@
+module QuickTravel
+  module InitFromHash
+    def initialize(hash = {})
+      return nil if hash.blank?
+
+      hash.each do |attr, val|
+        # set datamember of the object using hash key and value
+        if respond_to?("#{attr}=")
+          send("#{attr}=", val)
+        else
+          instance_variable_set("@#{attr}".to_sym, val)
+        end
+      end
+    end
+  end
+end