booker_ruby 1.14.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cfd498c0a58816c09c0bf5211fde0a6f4e56a76d
-  data.tar.gz: 4f7a16d04823d03eff57c794425914e5c6c5876b
+  metadata.gz: 131d08ade59a2472091a0a054a83a44e4ca61b3a
+  data.tar.gz: 1b310a5e471337ef53435cd490fefac9a6d70d12
 SHA512:
-  metadata.gz: 73606447296d323f61f298a52627c06eefe1fdc8c117d4edd69a3cd8171d965ef2931baaccf3e555cb8a5a8c70a23e005c3067b4aa83d34a83f5a5121b212beb
-  data.tar.gz: b279e278941f1bf91ebf09335d667044273597d741fb501ebc0286d3ac46d5d6ebbe0dd5bdf037549f67057cd6a9e3e5921ccddb2089f95ad4123546b621c303
+  metadata.gz: eb7ca3e5420dfdcf5844bd3eb95da5372322998e000b76c3260d4399360ffde955c51061b9b4ee1bd88b991b1af25b09cb5df83c296afbe8514dc1dab386f2b4
+  data.tar.gz: ea1ea1d93267b933769e09516ffb1f4330819c278fca418443e710443e995ad7da2d65209f55560da699a8b37ca3945a2afc33c758804316ef2ee051d1882826

data/lib/booker/client.rb

@@ -1,27 +1,55 @@
 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
-
-    ACCESS_TOKEN_HTTP_METHOD = :get
-    ACCESS_TOKEN_ENDPOINT = '/access_token'.freeze
-    TimeZone = 'Eastern Time (US & Canada)'.freeze
+    attr_accessor :base_url, :auth_base_url, :client_id, :client_secret, :temp_access_token,
+                  :temp_access_token_expires_at, :token_store, :token_store_callback_method, :api_subscription_key,
+                  :access_token_scope, :refresh_token, :location_id, :auth_with_client_credentials
+
+    CREATE_TOKEN_CONTENT_TYPE = 'application/x-www-form-urlencoded'.freeze
+    CLIENT_CREDENTIALS_GRANT_TYPE = 'client_credentials'.freeze
+    REFRESH_TOKEN_GRANT_TYPE = 'refresh_token'.freeze
+    CREATE_TOKEN_PATH = '/v5/auth/connect/token'.freeze
+    UPDATE_TOKEN_CONTEXT_PATH = '/v5/auth/context/update'.freeze
+    VALID_ACCESS_TOKEN_SCOPES = %w(public merchant parter-payment internal).map(&:freeze).freeze
+    API_GATEWAY_ERRORS = {
+      503 => Booker::ServiceUnavailable,
+      504 => Booker::ServiceUnavailable,
+      429 => Booker::RateLimitExceeded,
+      401 => Booker::InvalidApiCredentials,
+      403 => Booker::InvalidApiCredentials
+    }.freeze
+    BOOKER_SERVER_TIMEZONE = 'Eastern Time (US & Canada)'.freeze
+    DEFAULT_CONTENT_TYPE = 'application/json'.freeze
+    ENV_BASE_URL_KEY = 'BOOKER_API_BASE_URL'.freeze
+    DEFAULT_BASE_URL = 'https://api-staging.booker.com'.freeze
+    DEFAULT_AUTH_BASE_URL = 'https://api-staging.booker.com'
 
     def initialize(options = {})
       options.each { |key, value| send(:"#{key}=", value) }
       self.base_url ||= get_base_url
+      self.auth_base_url ||= ENV['BOOKER_API_BASE_URL'] || DEFAULT_AUTH_BASE_URL
       self.client_id ||= ENV['BOOKER_CLIENT_ID']
       self.client_secret ||= ENV['BOOKER_CLIENT_SECRET']
+      self.api_subscription_key ||= ENV['BOOKER_API_SUBSCRIPTION_KEY']
+      if self.auth_with_client_credentials.nil?
+        self.auth_with_client_credentials = ENV['BOOKER_API_AUTH_WITH_CLIENT_CREDENTIALS'] == 'true'
+      end
+      if self.temp_access_token.present?
+        begin
+          self.temp_access_token_expires_at = token_expires_at(self.temp_access_token)
+          self.access_token_scope = token_scope(self.temp_access_token)
+        rescue JWT::ExpiredSignature => ex
+          raise ex unless self.auth_with_client_credentials || self.refresh_token.present?
+        end
+      end
+      if self.access_token_scope.blank?
+        self.access_token_scope = VALID_ACCESS_TOKEN_SCOPES.first
+      elsif !self.access_token_scope.in?(VALID_ACCESS_TOKEN_SCOPES)
+        raise ArgumentError, "access_token_scope must be one of: #{VALID_ACCESS_TOKEN_SCOPES.join(', ')}"
+      end
     end
 
     def get_base_url
-      env_key = try(:env_base_url_key)
-
-      if env_key.present?
-        ENV[env_key] || try(:default_base_url)
-      else
-        try(:default_base_url)
-      end
+      ENV[self.class::ENV_BASE_URL_KEY] || self.class::DEFAULT_BASE_URL
     end
 
     def get(path, params, booker_model=nil)
@@ -42,15 +70,21 @@ module Booker
       build_resources(booker_resources, booker_model)
     end
 
+    def delete(path, params=nil, body=nil, booker_model=nil)
+      booker_resources = get_booker_resources(:delete, path, params, body.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']
+      page_size = params[:PageSize]
+      page_number = params[:PageNumber]
 
-      if page_size.nil? || page_size < 1 || page_number.nil? || page_number < 1 || !params['UsePaging']
+      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."
+      puts "fetching #{path} with #{params.except(:access_token)}. #{fetched.length} results so far."
 
       results = self.send(method, path, params, model)
 
@@ -65,7 +99,7 @@ module Booker
         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
+          new_params[:PageNumber] = page_number + 1
           paginated_request(method: method, path: path, params: new_params, model: model, fetched: fetched)
         else
           fetched
@@ -82,20 +116,28 @@ module Booker
 
       # Allow it to retry the first time unless it is an authorization error
       begin
-        booker_resources = handle_errors!(url, http_options, HTTParty.send(http_method, url, http_options))
+        response = handle_errors!(url, http_options, HTTParty.send(http_method, url, http_options))
       rescue Booker::Error, Net::ReadTimeout => ex
         if ex.is_a? Booker::InvalidApiCredentials
           raise ex
         else
           sleep 1
-          booker_resources = nil
+          response = nil # Force a retry (see logic below)
         end
       end
 
-      return results_from_response(booker_resources, booker_model) if booker_resources.present?
-      booker_resources = handle_errors!(url, http_options, HTTParty.send(http_method, url, http_options))
-      return results_from_response(booker_resources, booker_model) if booker_resources.present?
-      raise Booker::Error.new(url: url, request: http_options, response: booker_resources)
+      unless response.nil? || nil_or_empty_hash?(response.parsed_response)
+        return results_from_response(response, booker_model)
+      end
+
+      # Retry on blank responses (happens in certain v4 API methods in lieu of an actual error)
+      response = handle_errors!(url, http_options, HTTParty.send(http_method, url, http_options))
+      unless response.nil? || nil_or_empty_hash?(response.parsed_response)
+        return results_from_response(response, booker_model)
+      end
+
+      # Raise if response is still blank
+      raise Booker::Error.new(url: url, request: http_options, response: response)
     end
 
     def full_url(path)
@@ -106,6 +148,9 @@ module Booker
     def handle_errors!(url, request, response)
       puts "BOOKER RESPONSE: #{response}" if ENV['BOOKER_API_DEBUG'] == 'true'
 
+      error_class = API_GATEWAY_ERRORS[response.code]
+      raise error_class.new(url: url, request: request, response: response) if error_class
+
       ex = Booker::Error.new(url: url, request: request, response: response)
       if ex.error.present? || !response.success?
         case ex.error
@@ -126,13 +171,6 @@ module Booker
       (self.temp_access_token && !temp_access_token_expired?) ? self.temp_access_token : get_access_token
     end
 
-    def access_token_options
-      {
-          client_id: self.client_id,
-          client_secret: self.client_secret
-      }
-    end
-
     def update_token_store
       if self.token_store.present? && self.token_store_callback_method.present?
         self.token_store.send(self.token_store_callback_method, self.temp_access_token, self.temp_access_token_expires_at)
@@ -140,36 +178,88 @@ module Booker
     end
 
     def get_access_token
-      http_options = access_token_options
-      response = raise_invalid_api_credentials_for_empty_resp! { access_token_response(http_options) }
+      unless self.auth_with_client_credentials || self.refresh_token
+        raise ArgumentError, 'Cannot get new access token without auth_with_client_credentials or a refresh_token'
+      end
 
-      self.temp_access_token_expires_at = Time.now + response['expires_in'].to_i.seconds
-      self.temp_access_token = response['access_token']
+      resp = access_token_response
+      token = resp.parsed_response['access_token']
+      raise Booker::InvalidApiCredentials.new(response: resp) if token.blank?
+
+      if self.auth_with_client_credentials && self.location_id
+        self.temp_access_token = get_location_access_token(token, self.location_id)
+      else
+        self.temp_access_token = token
+      end
+
+      self.temp_access_token_expires_at = token_expires_at(self.temp_access_token)
 
       update_token_store
 
       self.temp_access_token
     end
 
-    def raise_invalid_api_credentials_for_empty_resp!
-      yield
-    rescue Booker::Error => ex
-      if (response = ex.response).present?
-        raise ex
-      else
-        raise Booker::InvalidApiCredentials.new(url: ex.url, request: ex.request, response: response)
+    def access_token_response
+      body = {
+        grant_type: self.auth_with_client_credentials ? CLIENT_CREDENTIALS_GRANT_TYPE : REFRESH_TOKEN_GRANT_TYPE,
+        client_id: self.client_id,
+        client_secret: self.client_secret,
+        scope: self.access_token_scope
+      }
+      body[:refresh_token] = self.refresh_token if body[:grant_type] == REFRESH_TOKEN_GRANT_TYPE
+      options = {
+        headers: {
+          'Content-Type' => CREATE_TOKEN_CONTENT_TYPE,
+          'Ocp-Apim-Subscription-Key' => self.api_subscription_key
+        },
+        body: body.to_query
+      }
+
+      url = "#{self.auth_base_url}#{CREATE_TOKEN_PATH}"
+
+      begin
+        handle_errors! url, options, HTTParty.post(url, options)
+      rescue Booker::ServiceUnavailable, Booker::RateLimitExceeded
+        # retry once
+        sleep 1
+        handle_errors! url, options, HTTParty.post(url, options)
       end
     end
 
-    def access_token_response(http_options)
-      send(self.class::ACCESS_TOKEN_HTTP_METHOD, self.class::ACCESS_TOKEN_ENDPOINT, http_options, nil)
+    def get_location_access_token(existing_token, location_id)
+      options = {
+        headers: {
+          'Content-Type' => DEFAULT_CONTENT_TYPE,
+          'Accept' => 'application/json',
+          'Authorization' => "Bearer #{existing_token}",
+          'Ocp-Apim-Subscription-Key' => self.api_subscription_key
+        },
+        query: {
+          locationId: location_id
+        },
+        open_timeout: 120
+      }
+      url = "#{self.auth_base_url}#{UPDATE_TOKEN_CONTEXT_PATH}"
+
+      begin
+        resp = handle_errors! url, options, HTTParty.post(url, options)
+      rescue Booker::ServiceUnavailable, Booker::RateLimitExceeded
+        # retry once
+        sleep 1
+        resp = handle_errors! url, options, HTTParty.post(url, options)
+      end
+
+      resp.parsed_response
     end
 
     private
       def request_options(query=nil, body=nil)
         options = {
           headers: {
-            'Content-Type' => 'application/json; charset=utf-8'
+            'Content-Type' => DEFAULT_CONTENT_TYPE,
+            'Accept' => DEFAULT_CONTENT_TYPE,
+            'Authorization' => "Bearer #{access_token}",
+            'Ocp-Apim-Subscription-Key' => self.api_subscription_key
           },
           open_timeout: 120
         }
@@ -196,17 +286,32 @@ module Booker
       end
 
       def results_from_response(response, booker_model=nil)
-        return response['Results'] unless response['Results'].nil?
+        parsed_response = response.parsed_response
+
+        return parsed_response unless parsed_response.is_a?(Hash)
+        return parsed_response['Results'] unless parsed_response['Results'].nil?
 
         if booker_model
           model_name = booker_model.to_s.demodulize
-          return response[model_name] unless response[model_name].nil?
+          return parsed_response[model_name] unless parsed_response[model_name].nil?
 
           pluralized = model_name.pluralize
-          return response[pluralized] unless response[pluralized].nil?
+          return parsed_response[pluralized] unless parsed_response[pluralized].nil?
         end
 
-        response.parsed_response if response
+        parsed_response
+      end
+
+      def nil_or_empty_hash?(obj)
+        obj.nil? || (obj.is_a?(Hash) && obj.blank?)
+      end
+
+      def token_expires_at(token)
+        Time.at(JWT.decode(token, nil, false)[0]['exp'])
+      end
+
+      def token_scope(token)
+        JWT.decode(token, nil, false)[0]['scope']
       end
   end
 end

data/lib/booker/errors.rb

@@ -9,8 +9,10 @@ module Booker
 
       if response.present?
         self.response = response
-        self.error = response['error'] || response['ErrorMessage']
-        self.description = response['error_description']
+        if response.parsed_response.is_a?(Hash)
+          self.error = response.parsed_response['error'] || response.parsed_response['ErrorMessage']
+          self.description = response.parsed_response['error_description']
+        end
       end
 
       self.url = url
@@ -18,4 +20,6 @@ module Booker
   end
 
   class InvalidApiCredentials < Error; end
+  class ServiceUnavailable < Error; end
+  class RateLimitExceeded < Error; end
 end

data/lib/booker/model.rb

@@ -0,0 +1,84 @@
+module Booker
+  class Model
+    CONSTANTIZE_MODULE = Booker
+
+    def initialize(options = {})
+      @attributes = []
+      options.each do |k, v|
+        send(:"#{k}=", v)
+        @attributes << k.to_sym
+      end
+    end
+
+    def to_hash
+      hash = {}
+      @attributes.each do |attr|
+        value = self.send(attr)
+        if value.is_a? Array
+          new_value = hash_list(value)
+        elsif value.is_a? Booker::Model
+          new_value = value.to_hash
+        elsif value.is_a? Time
+          new_value = self.class.try(:time_to_booker_datetime, value) || value
+        elsif value.is_a? Date
+          time = value.in_time_zone
+          new_value = self.class.try(:time_to_booker_datetime, time) || value
+        else
+          new_value = value
+        end
+        hash[attr] = new_value
+      end
+      hash
+    end
+
+    def self.from_hash(hash)
+      model = self.new
+      hash.each do |k, v|
+        if model.respond_to?(:"#{k}")
+          constantized = self.constantize(k)
+          if constantized
+            if v.is_a?(Array) && v.first.is_a?(Hash)
+              model.send(:"#{k}=", constantized.from_list(v))
+              next
+            elsif v.is_a? Hash
+              model.send(:"#{k}=", constantized.from_hash(v))
+              next
+            end
+          end
+          if v.is_a?(String) && v.start_with?('/Date(')
+            model.send(:"#{k}=", try(:time_from_booker_datetime, v) || v)
+            next
+          end
+          model.send(:"#{k}=", v)
+        end
+      end
+      model
+    end
+
+    def to_json; Oj.dump(to_hash, mode: :compat); end
+
+    def self.from_list(array); array.map { |item| self.from_hash(item) }; end
+
+    def self.constantize(key)
+      begin
+        self::CONSTANTIZE_MODULE.const_get key.to_s.camelize.singularize
+      rescue NameError
+        nil
+      end
+    end
+
+    private
+
+    def hash_list(array)
+      array.map do |item|
+        if item.is_a? Array
+          hash_list(item)
+        elsif item.is_a? Booker::Model
+          item.to_hash
+        else
+          item
+        end
+      end
+    end
+  end
+end

data/lib/booker/v4.1/availability.rb

@@ -0,0 +1,21 @@
+module Booker
+  module V41
+    class Availability < Client
+      include Booker::V4::RequestHelper
+
+      API_METHODS = {
+        class_availability: '/v4.1/availability/availability/class'.freeze
+      }.freeze
+
+      def class_availability(location_id:, from_start_date_time:, to_start_date_time:, options: {})
+        post API_METHODS[:class_availability], build_params({
+          FromStartDateTime: from_start_date_time,
+          LocationID: location_id,
+          OnlyIfAvailable: true,
+          ToStartDateTime: to_start_date_time,
+          ExcludeClosedDates: true
+        }, options), Booker::V4::Models::ClassInstance
+      end
+    end
+  end
+end

data/lib/booker/v4.1/booking.rb

@@ -0,0 +1,87 @@
+module Booker
+  module V41
+    class Booking < Client
+      include Booker::V4::RequestHelper
+
+      API_METHODS = {
+        appointment: '/v4.1/booking/appointment'.freeze,
+        cancel_appointment: '/v4.1/booking/appointment/cancel'.freeze,
+        create_appointment: '/v4.1/booking/appointment/create'.freeze,
+        appointment_hold: '/v4.1/booking/appointment/hold'.freeze,
+        employees: '/v4.1/booking/employees'.freeze,
+        services: '/v4.1/booking/services'.freeze,
+        location: '/v4.1/booking/location'.freeze,
+        locations: '/v4.1/booking/locations'.freeze
+      }.freeze
+
+      def appointment(id:)
+        get "#{API_METHODS[:appointment]}/#{id}", build_params, Booker::V4::Models::Appointment
+      end
+
+      def cancel_appointment(id:, options:{})
+        put API_METHODS[:cancel_appointment], build_params({ID: id}, options), Booker::V4::Models::Appointment
+      end
+
+      def create_appointment(location_id:, available_time:, customer:, options: {})
+        post API_METHODS[:create_appointment], build_params({
+          LocationID: location_id,
+          ItineraryTimeSlotList: [
+            TreatmentTimeSlots: [available_time]
+          ],
+          Customer: customer
+        }, options), Booker::V4::Models::Appointment
+      end
+
+      def create_appointment_hold(location_id:, available_time:, customer:, options: {})
+        post API_METHODS[:appointment_hold], build_params({
+          LocationID: location_id,
+          ItineraryTimeSlot: {
+            TreatmentTimeSlots: [available_time]
+          },
+          Customer: customer
+        }, options)
+      end
+
+      def delete_appointment_hold(location_id:, incomplete_appointment_id:)
+        delete API_METHODS[:appointment_hold], nil, build_params({
+          LocationID: location_id,
+          IncompleteAppointmentID: incomplete_appointment_id
+        })
+      end
+
+      def employees(location_id:, fetch_all: true, options: {})
+        paginated_request(
+          method: :post,
+          path: API_METHODS[:employees],
+          params: build_params({LocationID: location_id}, options, true),
+          model: Booker::V4::Models::Employee,
+          fetch_all: fetch_all
+        )
+      end
+
+      def location(id:)
+        response = get("#{API_METHODS[:location]}/#{id}", build_params)
+        Booker::V4::Models::Location.from_hash(response)
+      end
+
+      def locations(options: {})
+        paginated_request(
+          method: :post,
+          path: API_METHODS[:locations],
+          params: build_params({}, options, true),
+          model: Booker::V4::Models::Location
+        )
+      end
+
+      def services(location_id:, fetch_all: true, params: {})
+        paginated_request(
+          method: :post,
+          path: API_METHODS[:services],
+          params: build_params({LocationID: location_id}, params, true),
+          model: Booker::V4::Models::Treatment,
+          fetch_all: fetch_all
+        )
+      end
+    end
+  end
+end