booker_ruby 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8b39923daabcfec1bb62dd8c6c0a479249cd6846
+  data.tar.gz: cd5967c5745415270ea1d9d16f53b58b2a5d11f0
+SHA512:
+  metadata.gz: bc9b5ff26181dcb216b03755ac25467e87ee928a9156a6f726692bf741bbfd5ccb1bfc321076aa8f1cd68283d53e9fe6e3d9f0f4aa0fa38f1ac634717f2f1867
+  data.tar.gz: 3013213b0f4c4d360ddabbf8877b1d68a079bbc24a0872c9a3c763e20410293c8cfff9ea82607784086f27637ab8d82c0bdcf5d6273984df874d2f17ded0b6e9

data/lib/booker/booker.rb

@@ -0,0 +1,5 @@
+module Booker
+  def self.config
+    @config ||= {}
+  end
+end

data/lib/booker/business_client.rb

@@ -0,0 +1,32 @@
+module Booker
+  class BusinessClient < Client
+    include Booker::BusinessREST
+
+    attr_accessor :booker_account_name, :booker_username, :booker_password
+
+    def initialize(options={})
+      self.base_url = ENV['BOOKER_BUSINESS_SERVICE_URL'] || 'https://apicurrent-app.booker.ninja/webservice4/json/BusinessService.svc'
+      super
+    end
+
+    def get_access_token
+      http_options = {
+        client_id: self.client_id,
+        client_secret: self.client_secret,
+        'AccountName' => self.booker_account_name,
+        'UserName' => self.booker_username,
+        'Password' => self.booker_password
+      }
+      response = post('/accountlogin', http_options, nil).parsed_response
+
+      raise Booker::InvalidApiCredentials.new(http_options, response) unless response.present?
+
+      self.temp_access_token_expires_at = Time.now + response['expires_in'].to_i.seconds
+      self.temp_access_token = response['access_token']
+
+      update_token_store
+
+      self.temp_access_token
+    end
+  end
+end

data/lib/booker/business_rest.rb

@@ -0,0 +1,89 @@
+module Booker
+  module BusinessREST
+    include CommonREST
+
+    def get_logged_in_user
+      response = get('/user', build_params)
+      result = Booker::Models::User.from_hash(response['User'])
+      result.LocationID = response['LocationID']
+      result.BrandID = response['BrandID']
+      result
+    end
+
+    def get_location(booker_location_id:)
+      response = get("/location/#{booker_location_id}", build_params)
+      Booker::Models::Location.from_hash(response)
+    end
+
+    def find_locations(params: {})
+      paginated_request(
+          method: :post,
+          path: '/locations',
+          params: build_params({}, params, true),
+          model: Booker::Models::Location
+      )
+    end
+
+    def find_employees(booker_location_id:, fetch_all: true, params: {})
+      paginated_request(
+          method: :post,
+          path: '/employees',
+          params: build_params({'LocationID' => booker_location_id}, params, true),
+          model: Booker::Models::Employee,
+          fetch_all: fetch_all
+      )
+    end
+
+    def find_treatments(booker_location_id:, fetch_all: true, params: {})
+      paginated_request(
+          method: :post,
+          path: '/treatments',
+          params: build_params({'LocationID' => booker_location_id}, params, true),
+          model: Booker::Models::Treatment,
+          fetch_all: fetch_all
+      )
+    end
+
+    def find_customers(booker_location_id:, fetch_all: true, params: {})
+      additional_params = {
+          'FilterByExactLocationID' => true,
+          'LocationID' => booker_location_id,
+          'CustomerRecordType' => 1,
+      }
+
+      paginated_request(
+          method: :post,
+          path: '/customers',
+          params: build_params(additional_params, params, true),
+          model: Booker::Models::Customer,
+          fetch_all: fetch_all
+      )
+    end
+
+    def find_appointments(booker_location_id:, start_at:, end_at:, fetch_all: true, params: {})
+      additional_params = {
+          'LocationID' => booker_location_id,
+          'FromStartDate' => start_at,
+          'ToStartDate' => end_at
+      }
+
+      paginated_request(
+          method: :post,
+          path: '/appointments',
+          params: build_params(additional_params, params, true),
+          model: Booker::Models::Appointment,
+          fetch_all: fetch_all
+      )
+    end
+
+    def create_special(booker_location_id:, start_date:, end_date:, coupon_code:, name:, params: {})
+      post('/special', build_params({
+            'LocationID' => booker_location_id,
+            'ApplicableStartDate' => start_date.in_time_zone,
+            'ApplicableEndDate' => end_date.in_time_zone,
+            'CouponCode' => coupon_code,
+            'Name' => name
+          }, params))
+    end
+  end
+end

data/lib/booker/client.rb

@@ -0,0 +1,182 @@
+module Booker
+  class Client
+    attr_accessor :base_url, :client_id, :client_secret, :temp_access_token, :temp_access_token_expires_at, :token_store, :token_store_callback_method
+
+    TimeZone = 'Eastern Time (US & Canada)'.freeze
+
+    def initialize(options = {})
+      options.each do |key, value|
+        send(:"#{key}=", value)
+      end
+    end
+
+    def get(path, params, booker_model=nil)
+      booker_resources = get_booker_resources(:get, path, params, nil, booker_model)
+
+      build_resources(booker_resources, booker_model)
+    end
+
+    def post(path, data, booker_model=nil)
+      booker_resources = get_booker_resources(:post, path, nil, data.to_json, booker_model)
+
+      build_resources(booker_resources, booker_model)
+    end
+
+    def put(path, data, booker_model=nil)
+      booker_resources = get_booker_resources(:put, path, nil, data.to_json, booker_model)
+
+      build_resources(booker_resources, booker_model)
+    end
+
+    def paginated_request(method:, path:, params:, model: nil, fetched: [], fetch_all: true)
+      page_size = params['PageSize']
+      page_number = params['PageNumber']
+
+      if page_size.nil? || page_size < 1 || page_number.nil? || page_number < 1 || !params['UsePaging']
+        raise ArgumentError, 'params must include valid PageSize, PageNumber and UsePaging'
+      end
+
+      puts "fetching #{path} with #{params.except('access_token')}. #{fetched.length} results so far."
+
+      results = self.send(method, path, params, model)
+
+      unless results.is_a?(Array)
+        raise StandardError, "Result from paginated request to #{path} with params: #{params} is not a collection"
+      end
+
+      fetched.concat(results)
+      results_length = results.length
+
+      if fetch_all
+        if results_length > 0
+          # TODO (#111186744): Add logging to see if any pages with less than expected data (as seen in the /appointments endpoint)
+          new_params = params.deep_dup
+          new_params['PageNumber'] = page_number + 1
+          paginated_request(method: method, path: path, params: new_params, model: model, fetched: fetched)
+        else
+          fetched
+        end
+      else
+        results
+      end
+    end
+
+    def log_issue(message, extra_info = {})
+      if (log_message_block = Booker.config[:log_message])
+        log_message_block.call(message, extra_info)
+      end
+    end
+
+    def get_booker_resources(http_method, path, params=nil, body=nil, booker_model=nil)
+      http_options = request_options(params, body)
+      puts "BOOKER REQUEST: #{http_method} #{path} #{http_options}" if ENV['BOOKER_API_DEBUG'] == 'true'
+
+      # Allow it to retry the first time unless it is an authorization error
+      begin
+        booker_resources = handle_errors!(http_options, HTTParty.send(http_method, "#{self.base_url}#{path}", http_options))
+      rescue Booker::Error, Net::ReadTimeout => ex
+        if ex.is_a? Booker::InvalidApiCredentials
+          raise ex
+        else
+          sleep 1
+          booker_resources = nil
+        end
+      end
+
+      if booker_resources
+        results_from_response(booker_resources, booker_model)
+      else
+        booker_resources = handle_errors!(http_options, HTTParty.send(http_method, "#{self.base_url}#{path}", http_options))
+
+        if booker_resources
+          results_from_response(booker_resources, booker_model)
+        else
+          raise Booker::Error.new(http_options, booker_resources)
+        end
+      end
+    end
+
+    def handle_errors!(request, response)
+      puts "BOOKER RESPONSE: #{response}" if ENV['BOOKER_API_DEBUG'] == 'true'
+
+      ex = Booker::Error.new(request, response)
+      if ex.error.present? || !response.success?
+        case ex.error
+          when 'invalid_client'
+            raise Booker::InvalidApiCredentials.new(request, response)
+          when 'invalid access token'
+            get_access_token
+            return nil
+          else
+            raise ex
+        end
+      end
+
+      response
+    end
+
+    def access_token
+      if self.temp_access_token && !temp_access_token_expired?
+        self.temp_access_token
+      else
+        get_access_token
+      end
+    end
+
+    private
+      def request_options(query=nil, body=nil)
+        options = {
+          headers: {
+            'Content-Type' => 'application/json; charset=utf-8'
+          },
+          timeout: 120
+        }
+
+        if body.present?
+          options[:body] = body
+        end
+
+        if query.present?
+          options[:query] = query
+        end
+
+        options
+      end
+
+      def build_resources(resources, booker_model)
+        return resources if booker_model.nil?
+
+        if resources.is_a? Hash
+          booker_model.from_hash(resources)
+        elsif resources.is_a? Array
+          booker_model.from_list(resources)
+        else
+          resources
+        end
+      end
+
+      def temp_access_token_expired?
+        self.temp_access_token_expires_at.nil? || self.temp_access_token_expires_at <= Time.now
+      end
+
+      def update_token_store
+        if self.token_store && self.token_store_callback_method
+          token_store.send(token_store_callback_method, self.temp_access_token, self.temp_access_token_expires_at)
+        end
+      end
+
+      def results_from_response(response, booker_model=nil)
+        return response['Results'] unless response['Results'].nil?
+
+        if booker_model
+          model_name = booker_model.to_s.demodulize
+          return response[model_name] unless response[model_name].nil?
+
+          pluralized = model_name.pluralize
+          return response[pluralized] unless response[pluralized].nil?
+        end
+
+        response
+      end
+  end
+end

data/lib/booker/common_rest.rb

@@ -0,0 +1,38 @@
+module Booker
+  module CommonREST
+    DEFAULT_PAGINATION_PARAMS = {
+        'UsePaging' => true,
+        'PageSize' => Integer(ENV['BOOKER_DEFAULT_PAGE_SIZE'] || 10),
+        'PageNumber' => 1
+    }
+
+    def get_online_booking_settings(booker_location_id:)
+      response = get("/location/#{booker_location_id}/online_booking_settings", build_params)
+      Booker::Models::OnlineBookingSettings.from_hash(response['OnlineBookingSettings'])
+    end
+
+    def confirm_appointment(appointment_id:)
+      put '/appointment/confirm', build_params('ID' => appointment_id), Booker::Models::Appointment
+    end
+
+    private
+
+      def build_params(default_params={}, overrides={}, paginated=false)
+        merged = {"access_token" => access_token}.merge(default_params.merge(overrides))
+
+        merged.each do |k, v|
+          if v.is_a?(Time) || v.is_a?(DateTime)
+            merged[k] = Booker::Models::Model.time_to_booker_datetime(v)
+          elsif v.is_a?(Date)
+            merged[k] = Booker::Models::Model.time_to_booker_datetime(v.in_time_zone)
+          end
+        end
+
+        if paginated
+          DEFAULT_PAGINATION_PARAMS.merge(merged)
+        else
+          merged
+        end
+      end
+  end
+end

data/lib/booker/customer_client.rb

@@ -0,0 +1,31 @@
+module Booker
+  class CustomerClient < Client
+    include Booker::CustomerREST
+
+    def initialize(options={})
+      self.base_url = ENV['BOOKER_CUSTOMER_SERVICE_URL'] || 'https://apicurrent-app.booker.ninja/webservice4/json/CustomerService.svc'
+      self.token_store = GenericTokenStore
+      self.token_store_callback_method = :update_booker_access_token!
+      super
+    end
+
+    def get_access_token
+      http_options = {
+        client_id: self.client_id,
+        client_secret: self.client_secret,
+        grant_type: 'client_credentials'
+      }
+
+      response = get("/access_token", http_options, nil).parsed_response
+
+      raise Booker::InvalidApiCredentials.new(http_options, response) unless response.present?
+
+      self.temp_access_token_expires_at = Time.now + response['expires_in'].to_i.seconds
+      self.temp_access_token = response['access_token']
+
+      update_token_store
+
+      self.temp_access_token
+    end
+  end
+end

data/lib/booker/customer_rest.rb

@@ -0,0 +1,43 @@
+module Booker
+  module CustomerREST
+    include CommonREST
+
+    def create_appointment(booker_location_id:, available_time:, customer:, options: {})
+      post '/appointment/create', build_params({
+            'LocationID' => booker_location_id,
+            'ItineraryTimeSlotList' => [
+              'TreatmentTimeSlots' => [available_time]
+            ],
+            'Customer' => customer
+          }, options), Booker::Models::Appointment
+    end
+
+    def create_class_appointment(booker_location_id:, class_instance_id:, customer:, options: {})
+      post '/class_appointment/create', build_params({
+            'LocationID' => booker_location_id,
+            'ClassInstanceID' => class_instance_id,
+            'Customer' => customer
+          }, options), Booker::Models::Appointment
+    end
+
+    def run_multi_spa_multi_sub_category_availability(booker_location_ids:, treatment_sub_category_ids:, start_date_time:, end_date_time:, options: {})
+      post '/availability/multispamultisubcategory', build_params({
+            'LocationIDs' => booker_location_ids,
+            'TreatmentSubCategoryIDs' => treatment_sub_category_ids,
+            'StartDateTime' => start_date_time,
+            'EndDateTime' => end_date_time,
+            'MaxTimesPerTreatment' => 1000
+          }, options), Booker::Models::SpaEmployeeAvailabilitySearchItem
+    end
+
+    def run_class_availability(booker_location_id:, from_start_date_time:, to_start_date_time:, options: {})
+      post '/availability/class', build_params({
+          'FromStartDateTime' => from_start_date_time,
+          'LocationID' => booker_location_id,
+          'OnlyIfAvailable' => true,
+          'ToStartDateTime' => to_start_date_time,
+          'ExcludeClosedDates' => true
+        }, options), Booker::Models::ClassInstance
+    end
+  end
+end

data/lib/booker/errors.rb

@@ -0,0 +1,19 @@
+module Booker
+  class Error < StandardError
+    attr_accessor :error, :description, :request, :response
+
+    def initialize(request = nil, response = nil)
+      if request.present?
+        self.request = request
+      end
+
+      if response.present?
+        self.response = response
+        self.error = response['error'] || response['ErrorMessage']
+        self.description = response['error_description']
+      end
+    end
+  end
+
+  class InvalidApiCredentials < Error; end
+end