quicktravel_client 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d115ad4405fbddb775a4e3c83e85e6e1577dfc6a
+  data.tar.gz: 422e5e9df4d27248109ede5ca9ef390398029fed
+SHA512:
+  metadata.gz: f326cf1e9778cbb0b11523e1c6c89f1ce3b5febaba6d9ce61f90dc58b3e0371994ea8b2fd9e7f78a08d421ed91cf0c02edd066ce8631267f2beee00752510781
+  data.tar.gz: b5c0b87403273ded2efe88d85c2511f7fff40763b1b88c9b14a1dc5cc71905f96f4eaeee60c1973421f13c0fa1fa2a38ea9dad912c5aab548c598dcaee7a475f

data/.gitignore

@@ -0,0 +1,25 @@
+pkg
+coverage
+Gemfile.lock
+
+# Temp files
+tmp
+*.swp
+*~
+\#*
+.\#*
+*.orig
+*.DS_Store
+
+# Log files
+/log
+/debug.log
+
+# Ide droppings
+/.idea
+/.eclipse
+/nbproject
+/.redcar
+/tags
+/.tags
+/TAGS

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rubocop.yml

@@ -0,0 +1,13 @@
+Metrics/LineLength:
+  Max: 100
+
+Documentation:
+  Enabled: false
+
+Style/Blocks:
+  Enabled: false
+
+Style/TrivialAccessors:
+  AllowPredicates: true
+  AllowDSLWriters: true
+  ExactNameMatch:  true

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+rvm:
+  - 1.9
+  - 2.2
+script: "bundle && bundle exec rake coverage"
+gemfile:
+  - gemfiles/rails2.gemfile
+  - gemfiles/rails4.gemfile
+matrix:
+  exclude:
+    - rvm: 1.9
+      gemfile: gemfiles/rails4.gemfile
+    - rvm: 2.2
+      gemfile: gemfiles/rails2.gemfile
+notifications:
+  email:
+    - support@travellink.com.au
+  flowdock: e69dcafad1fea15c6b8c76e9ced965af

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+gemspec
+
+# TODO: Give money extensions proper versioning and release it
+gem 'money_extensions', github: 'sealink/money_extensions', branch: 'master'

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 SeaLink
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,17 @@
+QuickTravel
+===========
+
+[![Gem Version](https://badge.fury.io/rb/quicktravel_client.svg)](http://badge.fury.io/rb/quicktravel_client)
+[![Build Status](https://travis-ci.org/sealink/quicktravel_client.svg?branch=master)](https://travis-ci.org/sealink/quicktravel_client)
+[![Coverage Status](https://coveralls.io/repos/sealink/quicktravel_client/badge.svg)](https://coveralls.io/r/sealink/quicktravel_client)
+[![Dependency Status](https://gemnasium.com/sealink/quicktravel_client.svg)](https://gemnasium.com/sealink/quicktravel_client)
+[![Code Climate](https://codeclimate.com/github/sealink/quicktravel_client/badges/gpa.svg)](https://codeclimate.com/github/sealink/quicktravel_client)
+
+# DESCRIPTION
+
+Gives models that are integrated with the QuickTravel API
+
+# INSTALLATION
+
+Add to your Gemfile:
+gem 'quicktravel_client'

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+
+desc 'Default: run specs.'
+task :default => :spec
+
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+desc "Generate SimpleCov test coverage and open in your browser"
+task :coverage do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task['spec'].invoke
+end

data/bootstrap/boot.rb

@@ -0,0 +1,4 @@
+QUICK_TRAVEL_ACCESS_KEY = '6b50117c69393703d27ff1c346da8d60a087a39ca9604cefd65f1133af4c2a48'
+QUICK_TRAVEL_INTERNAL_URL = QUICK_TRAVEL_PUBLIC_URL = 'http://localhost:3000'
+
+require 'quick_travel'

data/examples/example_config.rb

@@ -0,0 +1,4 @@
+QuickTravel.configure do |config|
+  config.url = 'http://localhost:8080/'
+  config.access_key = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef'
+end

data/examples/login_example.rb

@@ -0,0 +1,25 @@
+# Add current dir to path
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+gem 'quicktravel_client'
+require 'quicktravel_client'
+
+require 'example_config'
+
+puts 'Login with username:'
+login = gets.chomp
+puts 'And password:'
+password = gets.chomp
+
+puts "Ok #{login}, just a tick..."
+result = begin
+  QuickTravel::Party.login(login: login, password: password)
+rescue QuickTravel::AdapterException
+  nil
+end
+
+if result
+  puts "Ok.  You'll do this time."
+else
+  puts 'No go, chappy'
+end

data/lib/extensions.rb

@@ -0,0 +1,12 @@
+require 'facets/kernel/blank'
+
+# Can not use. It inteferes with active support underscore
+# which is used by auto load! Such fun!
+#
+# See
+#  * core/facets/string/underscore.rb
+#  * core/facets/string/snakecase.rb
+#
+# Note, this method no longer converts `::` to `/`, in that case
+# use the {#pathize} method instead.
+#require 'facets/string/underscore'

data/lib/quick_travel/accommodation.rb

@@ -0,0 +1,72 @@
+require 'quick_travel/adapter'
+require 'quick_travel/bed_configuration'
+require 'quick_travel/room_facility'
+
+module QuickTravel
+  class Accommodation < Adapter
+    # TODO: find a dynamic way to provide getter/setters for all data members instead of writing all of them.
+
+    attr_accessor :book_before_level, :book_before_units, :bookable_individually, :bookable_online, :booking_notes, :code, :created_at
+    attr_accessor :days_before_inventory_expires, :default_capacity, :deposit_id, :disclaimer_id, :expiry_level, :expiry_units, :fare_basis_pointer_id
+    attr_accessor :frequent_traveller_points_multiplier, :guardian_minimum_age, :id, :inline_cost_in_cents, :inline_price_in_cents, :inline_pricing
+    attr_accessor :inventory_type, :active, :location_id, :masterpoint_resource_id, :maximum_occupancy, :maximum_passengers, :maximum_passengers_online
+    attr_accessor :maximum_weight, :minimum_age, :minimum_passengers, :name, :no_expiry, :non_commissionable, :on_request_after_inventory_expiration
+    attr_accessor :overriding_passenger_ticket_format_id, :overriding_reservation_ticket_format_id, :overriding_vehicle_ticket_format_id
+    attr_accessor :product_type_id, :property_id, :property_type_id, :reason_required, :report_changes, :required_number_of_vehicles
+    attr_accessor :resource_category_id, :restrict_to_client_types, :star_rating, :type, :unlimited_uses, :updated_at, :uses, :vendor_id
+    attr_accessor :availability, :minimum_bookable_duration, :description,
+                  :minimum_price, :nightly_price
+    attr_accessor :on_request
+    attr_accessor :error
+
+    attr_reader :bed_configurations, :room_facilities
+
+    MAX_DAYS = 8
+
+    def bed_configurations=(hash_array)
+      @bed_configurations = hash_array.map { |bed_configuration_hash| BedConfiguration.new(bed_configuration_hash) }
+    end
+
+    def room_facilities=(hash_array)
+      @room_facilities = hash_array.map { |room_facility_hash| RoomFacility.new(room_facility_hash) }
+    end
+
+    # The minimum price may be in 'nightly' or 'whole-duration-totalled' form, depending on options given to API
+    #
+    # I use these accessors to set it up as is more sane for users of the class.
+    attr_accessor :minimum_nightly_price, :minimum_price_for_duration
+
+    def minimum_price_on(date)
+      return nil if minimum_price.blank? || minimum_price[date.to_s].blank?
+      Money.new(minimum_price[date.to_s])
+    end
+
+    def nightly_price_on(date)
+      return nil if nightly_price.blank? || nightly_price[date.to_s].blank?
+      Money.new(nightly_price[date.to_s])
+    end
+
+    def available_over_dates?(dates)
+      return false if dates.empty?
+      dates.all? { |date| available_on?(date.to_s) }
+    end
+
+    def available_on?(date)
+      availability[date.to_s]
+    end
+
+    # Returns resource -- use for full information
+    def full_information
+      return @full_resource if @full_resource.present?
+      @full_resource = Resource.first(@id) unless @id.blank?
+    end
+
+    def graphics=(graphics)
+      @graphic_attributes = graphics
+    end
+
+    def graphics
+      @graphics ||= @graphic_attributes.map { |g| QuickTravel::Graphic.new(g) }
+    end
+  end
+end

data/lib/quick_travel/adapter.rb

@@ -0,0 +1,283 @@
+require 'httparty'
+require 'pp'
+require 'json'
+require 'active_support/core_ext'
+require 'money'
+require 'money_extensions/money_field'
+
+require 'quick_travel/config'
+require 'quick_travel/adapter_exception'
+require 'quick_travel/init_from_hash'
+
+module QuickTravel
+  class Adapter
+    include HTTParty
+    include QuickTravel::InitFromHash
+    include MoneyField
+
+    class_attribute :api_base, :lookup
+
+    # In case of object_key_name, we need to extract each record by a key
+    #
+    # Example:
+    # [
+    #   { :passenger_type => {"position"=>1, "name"=>"Adult", "maximum_age"=>30, "id"=>1} },
+    #   { :passenger_type => {"position"=>2, "name"=>"Child", "maximum_age"=>15, "id"=>2} }
+    # ]
+    class_attribute :object_key # Key of sub-objects (i.e. convert under a key)
+
+    def initialize(hash = {})
+      return nil if hash.blank?
+      super(Parser.new(hash).parsed_attributes)
+    end
+
+    def self.find(id, opts = {})
+      if lookup
+        all.detect { |o| o.id == id.to_i }
+      else
+        find_all!("#{api_base}/#{id}.json", opts).first
+      end
+    end
+
+    def self.all(opts = {})
+      if lookup
+        QuickTravel::Cache.cache("#{name}.all") {
+          find_all!("#{api_base}.json", opts)
+        }
+      else
+        find_all!("#{api_base}.json", opts)
+      end
+    end
+
+    def self.create(options = {})
+      post_and_validate("#{api_base}.json", options)
+    end
+
+    def self.update(id, options = {})
+      put_and_validate("#{api_base}/#{id}.json", options)
+    end
+
+    def self.qt_date_format_conversion(str)
+      qt_date_format_conversion!(str)
+    rescue ArgumentError
+    end
+
+    def self.qt_date_format_conversion!(str)
+      Date.strptime(str, '%d/%m/%Y').strftime('%d-%m-%Y')
+    end
+
+    def to_hash
+      instance_values
+    end
+
+    protected
+
+    # Find first
+    def self.generic_first(request_path, opts = {})
+      find_all!(request_path, opts).first
+    end
+
+    def self.find_all!(request_path, opts = {})
+      response = get_and_validate(request_path, opts, return_response_object: true)
+
+      deserializer = Deserializer.new(response.parsed_response)
+      objects = Array.wrap(deserializer.extract_under_root(self))
+
+      if response.headers['pagination'].present?
+        pagination_headers = ::JSON.parse(response.headers['pagination'])
+        WillPaginate::Collection.create(pagination_headers['current_page'], pagination_headers['per_page'], pagination_headers['total_entries']) do |pager|
+          pager.replace(objects)
+        end
+      else
+        objects
+      end
+    end
+
+    class Deserializer
+      def initialize(data)
+        @data = data
+      end
+
+      # Extract the 'root' -- the data must be a direct collection of objects
+      #
+      #  opts[:object_key_name] => inside each hash extract attributes under a subkey (per object)
+      def extract_under_root(klass, opts = {})
+        self.class.extract(@data, klass, opts)
+      end
+
+      # Extract under a specified key in the data
+      def extract(key, klass, opts = {})
+        collection_data = @data[key]
+        fail "No collection key [#{key}] found in data from API" if collection_data.blank?
+        self.class.extract(collection_data, klass, opts)
+      end
+
+      def self.extract(objects, klass, opts = {})
+        objects = Array.wrap(objects)
+        objects.map! { |item| item[opts[:object_key_name]] } if opts[:object_key_name]
+        objects.map! { |item| klass.new(item) }
+
+        # if opts[:page] && opts[:per_page]
+        # objects = WillPaginate::Collection.create(opts[:page], opts[:per_page], opts).replace(objects)
+        objects
+      end
+    end
+
+    # The above generic_first find_all and the above find
+    # all suck
+    #
+    # We should make it standard behaviour that objects
+    # instantiate on get...
+    #
+    # Also, we should combine the two methods (get and validate) automatically...
+    #
+    #  -> I found one - we can set custom parser()
+    #     but that won't have access to response code only the body
+    #
+    #  Better idea:
+    #  Just override get, put, post and delete?
+    #  If you need the originals, alias as raw.get() ?
+    #  Seems to solve both issues...
+
+    def get_and_validate(path, query = {}, opts = {})
+      self.class.get_and_validate(path, query, opts)
+    end
+
+    def post_and_validate(path, query = {}, opts = {})
+      self.class.post_and_validate(path, query, opts)
+    end
+
+    def put_and_validate(path, query = {}, opts = {})
+      self.class.put_and_validate(path, query, opts)
+    end
+
+    def delete_and_validate(path, query = {}, opts = {})
+      self.class.delete_and_validate(path, query, opts)
+    end
+
+    def self.get_and_validate(path, query = {}, opts = {})
+      call_and_validate(:get, path, query, opts)
+    end
+
+    def self.post_and_validate(path, query = {}, opts = {})
+      call_and_validate(:post, path, query, opts)
+    end
+
+    def self.put_and_validate(path, query = {}, opts = {})
+      call_and_validate(:put, path, query, opts)
+    end
+
+    def self.delete_and_validate(path, query = {}, opts = {})
+      call_and_validate(:delete, path, query, opts)
+    end
+
+    def self.call_and_validate(http_method, path, query = {}, opts = {})
+      http_params = opts.clone
+      return_response_object = http_params.delete(:return_response_object)
+      klass = self
+
+      # Set default token
+      http_params[:query] ||= query
+      http_params[:headers] ||= {}
+      http_params[:headers]['Content-length'] = '0' if http_params[:body].blank?
+      expect = http_params.delete(:expect)
+
+      # Use :body instead of :query for put/post.
+      #
+      # Causes webrick to give back error - -maybe other servers too.
+      http_params[:body] ||= {}
+      if [:put, :post].include?(http_method.to_sym)
+        http_params[:body].merge!(http_params.delete(:query))
+      end
+      http_params[:body][:access_key] = QuickTravel.config.access_key
+      http_params[:follow_redirects] = false
+
+      begin
+        response = klass.send(http_method, path, http_params)
+      rescue Errno::ECONNREFUSED
+        raise ConnectionError.new('Connection refused')
+      rescue SocketError
+        raise ConnectionError.new('Socket error')
+      rescue Timeout::Error
+        raise ConnectionError.new('Timeout error')
+      end
+
+      if expect && expect == :json && !response.is_a?(Hash)
+        fail AdapterException, <<-FAIL
+          Request expected to be json but failed. Debug information below:
+          http_method: #{http_method.inspect}
+          path: #{path.inspect}
+          http_params: #{http_params.inspect}
+          response object: #{response.inspect}
+          parsed_response: #{response.parsed_response.inspect}
+        FAIL
+      end
+
+      klass.validate!(response)
+
+      if return_response_object
+        response
+      else
+        response.parsed_response
+      end
+    end
+
+    # Do standard validations on response
+    #
+    # Firstly, check if a valid HTTP code was returned
+    # Secondly, check for presence of "error" key in returned hash
+    def self.validate!(response)
+      case response.code
+        when 300..399 # redirects
+          fail ConnectionError.new('We were redirected. QT YML configuration appears to be incorrect. Verify your URL and API.')
+        when 400..599 # client and server errors
+          fail AdapterException.new(response)
+      end
+
+      if response_contains_error?(response)
+        fail AdapterException, response
+      end
+    end
+
+    def self.response_contains_error?(response)
+      parsed_response = response.parsed_response
+      parsed_response.is_a?(Hash) && parsed_response.key?('error')
+    end
+  end
+
+  class Parser
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def parsed_attributes
+      @parsed_attributes ||= parse_attributes
+    end
+
+    private
+
+    def parse_attributes
+      attributes.map.with_object({}) do |(attribute, value), hash|
+        hash[attribute] = parse(attribute, value)
+      end
+    end
+
+    def parse(attribute, value)
+      return nil if value.nil?
+      return convert(value, :to_date) if attribute.to_s.ends_with?('_date')
+      # to_datetime as it converts to app time zone, to_time converts to system time zone
+      return convert(value, :to_datetime) if attribute.to_s.ends_with?('_time')
+      return convert(value, :to_datetime) if attribute.to_s.ends_with?('_at')
+      value
+    end
+
+    def convert(value, conversion_method)
+      convertable_value = value.is_a?(Hash) ? value['_value'] : value
+      convertable_value.send(conversion_method)
+    end
+  end
+end

data/lib/quick_travel/adapter_exception.rb

@@ -0,0 +1,20 @@
+module QuickTravel
+  class AdapterException < Exception
+    attr_reader :response
+
+    def initialize(response)
+      @response = if response.is_a? String
+                    { 'error' => response }
+                  else
+                    response.parsed_response
+                  end
+
+      error_message = @response.fetch('error', "We're sorry, but something went wrong. Please call us.")
+      super(error_message)
+    end
+
+    def error_type
+      @response.fetch('error_type', 'unspecified')
+    end
+  end
+end

data/lib/quick_travel/address.rb

@@ -0,0 +1,27 @@
+require 'quick_travel/adapter'
+require 'geokit'
+
+module QuickTravel
+  class Address < Adapter
+    attr_accessor :address_line1, :address_line2, :city, :country_id, :id, :post_code, :state, :country_name
+
+    def initialize(hash)
+      super(hash)
+      if @country_id == AUSTRALIA_COUNTRY_ID
+        @country_name = 'Australia'
+      end
+    end
+
+    def geocode
+      @_geocode ||= QuickTravel::Cache.cache("geocode_#{self}") {
+        Geokit::Geocoders::MultiGeocoder.geocode(to_s)
+      }
+    rescue Geokit::Geocoders::TooManyQueriesError
+      nil # do not cache, do not error
+    end
+
+    def to_s
+      "#{address_line1} #{address_line2}, #{city}, #{post_code}, #{state}, #{country_name}"
+    end
+  end
+end

data/lib/quick_travel/adjustment.rb

@@ -0,0 +1,8 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class Adjustment < Adapter
+    attr_accessor :id, :description, :gross_in_cents
+    money :gross
+  end
+end

data/lib/quick_travel/background_check.rb

@@ -0,0 +1,9 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class BackgroundCheck < Adapter
+    def self.check(options = {})
+      get_and_validate('/background_check/check.json', options)
+    end
+  end
+end

data/lib/quick_travel/bed_configuration.rb

@@ -0,0 +1,7 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class BedConfiguration < Adapter
+    attr_accessor :created_at, :creator_id, :id, :name, :overriding_fare_basis_pointer_id, :resource_id, :updated_at, :updator_id
+  end
+end

data/lib/quick_travel/bed_requirement.rb

@@ -0,0 +1,7 @@
+require 'quick_travel/adapter'
+
+module QuickTravel
+  class BedRequirement < Adapter
+    attr_accessor :id, :name, :single_bed_count, :double_bed_count
+  end
+end