booker_api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 834274a062ffb044410b9ccb07bb89c9c8f8c1ee
+  data.tar.gz: e2e8c83d3a7a653ed77da005d63991a58d76533b
+SHA512:
+  metadata.gz: dcc528461d36104babb6fadab2ecc7995ad86b770dfe560143c3a8664fb671294ab8952973769f3533fd7241ac2d6e114124d26736a885490d8cfea62e439b71
+  data.tar.gz: 6537a29844b3cefefd97a397b65545bdd8dc39f61d881cdda6ad1387363e7186079aa4dbf00e11f1d3989f37987cb64d144f2540abb76432c71f982aec41f12c

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,22 @@
+module Booker
+  class BusinessClient < Client
+    include Booker::BusinessREST
+
+    ACCESS_TOKEN_HTTP_METHOD = :post
+    ACCESS_TOKEN_ENDPOINT = '/accountlogin'.freeze
+
+    attr_accessor :booker_account_name, :booker_username, :booker_password
+
+    def env_base_url_key; 'BOOKER_BUSINESS_SERVICE_URL'; end
+
+    def default_base_url; 'https://apicurrent-app.booker.ninja/webservice4/json/BusinessService.svc'; end
+
+    def access_token_options
+      super.merge!(
+          'AccountName' => self.booker_account_name,
+          'UserName' => self.booker_username,
+          'Password' => self.booker_password
+      )
+    end
+  end
+end

data/lib/booker/business_rest.rb

@@ -0,0 +1,130 @@
+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_day_schedules(booker_location_id:, params: {})
+      # Booker requires fromDate and toDate for JSON API, but does not use them when getDefaultDaySchedule is true
+      # So datetime used for these fields does not matter
+      random_datetime = Booker::Models::Model.time_to_booker_datetime(Time.now)
+
+      additional_params = {'getDefaultDaySchedule' => true, 'fromDate' => random_datetime, 'toDate' => random_datetime}
+      response = get("/location/#{booker_location_id}/schedule", build_params(additional_params, params))
+      response['LocationDaySchedules'].map { |sched| Booker::Models::LocationDaySchedule.from_hash(sched) }
+    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_date:, end_date:, fetch_all: true, params: {})
+      additional_params = {
+          'LocationID' => booker_location_id,
+          'FromStartDate' => start_date.to_date,
+          'ToStartDate' => end_date.to_date
+      }
+
+      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
+
+    def get_location_notification_settings(booker_location_id:)
+      response = get "/location/#{booker_location_id}/notification_settings", build_params
+      Booker::Models::NotificationSettings.from_hash response['NotificationSettings']
+    end
+
+    def update_location_notification_settings(booker_location_id:, send_appointment_reminders:)
+      put "/location/#{booker_location_id}/notification_settings", build_params({
+        NotificationSettings: {
+          SendAppointmentReminders: send_appointment_reminders
+        }
+      })
+    end
+
+    def get_location_feature_settings(booker_location_id:)
+      response = get "/location/#{booker_location_id}/feature_settings", build_params
+      Booker::Models::FeatureSettings.from_hash response['FeatureSettings']
+    end
+    
+    def get_appointment(appointment_id)
+      get "/appointment/#{appointment_id}", build_params
+    end
+    
+    def cancel_appointment(appointment_id)
+      put "/appointment/cancel", build_params({
+        'ID' => appointment_id
+      })
+    end
+    
+    def place_order(order_id, amount)
+      post "/order/#{order_id}/place_order", build_params
+    end
+    
+    def take_deposit(order_id)
+      post "/order/#{order_id}/deposit", build_params
+    end
+  end
+end

data/lib/booker/client.rb

@@ -0,0 +1,212 @@
+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
+
+    def initialize(options = {})
+      options.each { |key, value| send(:"#{key}=", value) }
+      self.base_url ||= get_base_url
+      self.client_id ||= ENV['BOOKER_CLIENT_ID']
+      self.client_secret ||= ENV['BOOKER_CLIENT_SECRET']
+    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
+    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 get_booker_resources(http_method, path, params=nil, body=nil, booker_model=nil)
+      http_options = request_options(params, body)
+      url = full_url(path)
+      puts "BOOKER REQUEST: #{http_method} #{url} #{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!(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
+        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)
+    end
+
+    def full_url(path)
+      uri = URI(path)
+      uri.scheme ? path : "#{self.base_url}#{path}"
+    end
+
+    def handle_errors!(url, request, response)
+      puts "BOOKER RESPONSE: #{response}" if ENV['BOOKER_API_DEBUG'] == 'true'
+
+      ex = Booker::Error.new(url: url, request: request, response: response)
+      if ex.error.present? || !response.success?
+        case ex.error
+          when 'invalid_client'
+            raise Booker::InvalidApiCredentials.new(url: url, request: request, response: response)
+          # when 'invalid access token'
+          #   get_access_token
+          #   return nil
+          else
+            raise ex
+        end
+      end
+
+      response
+    end
+
+    def access_token
+      (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)
+      end
+    end
+
+    def get_access_token
+      http_options = access_token_options
+      response = raise_invalid_api_credentials_for_empty_resp! { access_token_response(http_options) }
+
+      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
+
+    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)
+      end
+    end
+
+    def access_token_response(http_options)
+      send(self.class::ACCESS_TOKEN_HTTP_METHOD, self.class::ACCESS_TOKEN_ENDPOINT, http_options, nil)
+    end
+
+    private
+      def request_options(query=nil, body=nil)
+        options = {
+          headers: {
+            'Content-Type' => 'application/json; charset=utf-8'
+          },
+          open_timeout: 120
+        }
+
+        options[:body] = body if body.present?
+        options[:query] = query if query.present?
+        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 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.parsed_response if response
+      end
+  end
+end

data/lib/booker/common_rest.rb

@@ -0,0 +1,49 @@
+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
+
+    def get_location(booker_location_id:)
+      response = get("/location/#{booker_location_id}", build_params)
+      Booker::Models::Location.from_hash(response)
+    end
+
+    private
+
+      def build_params(default_params={}, overrides={}, paginated=false)
+        # merged = default_params.merge(overrides)
+        # merged.merge({"access_token" => access_token}) unless merged.has_key?("access_token")
+        original = {}
+        unless overrides.has_key?(:access_token)
+          original[:access_token] = access_token
+        end
+        merged = original.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/config/booker_country_ids_to_iso_codes.yml

@@ -0,0 +1,269 @@
+---
+  1: 'US'
+  2: 'CA'
+  3: 'AL'
+  4: 'DZ'
+  5: 'AS'
+  6: 'AD'
+  7: 'AO'
+  8: 'AI'
+  9: 'AG'
+  10: 'AR'
+  11: 'AM'
+  12: 'AW'
+  13: 'AU'
+  14: 'AT'
+  15: 'AZ'
+  16: 'AP'
+  17: 'BS'
+  18: 'BH'
+  19: 'BD'
+  20: 'BB'
+  21: 'BY'
+  22: 'BE'
+  23: 'BZ'
+  24: 'BJ'
+  25: 'BM'
+  26: 'BT'
+  27: 'BO'
+  28: 'BL'
+  29: 'BA'
+  30: 'BW'
+  31: 'BV'
+  32: 'BR'
+  33: 'IO'
+  34: 'BN'
+  35: 'BG'
+  36: 'BF'
+  37: 'BI'
+  38: 'KH'
+  39: 'CM'
+  41: 'IC'
+  42: 'CV'
+  43: 'KY'
+  44: 'CF'
+  45: 'TD'
+  46: 'CD'
+  47: 'CL'
+  48: 'CN'
+  49: 'CX'
+  50: 'CC'
+  51: 'CO'
+  52: 'KM'
+  53: 'ZP'
+  54: 'CK'
+  55: 'CR'
+  56: 'CI'
+  57: 'HR'
+  58: 'CB'
+  59: 'CY'
+  60: 'CZ'
+  61: 'DK'
+  62: 'DJ'
+  63: 'DM'
+  64: 'DO'
+  65: 'TP'
+  66: 'EC'
+  67: 'EG'
+  68: 'SV'
+  69: 'GB' # Must be GB not UK!!!
+  70: 'GQ'
+  71: 'ER'
+  72: 'EE'
+  73: 'ET'
+  74: 'FO'
+  75: 'FK'
+  76: 'FJ'
+  77: 'FI'
+  78: 'FR'
+  79: 'GF'
+  80: 'PF'
+  81: 'TF'
+  82: 'GA'
+  83: 'GM'
+  84: 'GE'
+  85: 'DE'
+  86: 'GH'
+  87: 'GI'
+  89: 'GR'
+  90: 'GL'
+  91: 'GD'
+  92: 'GP'
+  93: 'GU'
+  94: 'GT'
+  95: 'GN'
+  96: 'GW'
+  97: 'GY'
+  98: 'HT'
+  99: 'HM'
+  100: 'HN'
+  101: 'HK'
+  102: 'HU'
+  103: 'IS'
+  104: 'IN'
+  105: 'ID'
+  106: 'IE'
+  107: 'IL'
+  108: 'IT'
+  109: 'JM'
+  110: 'JP'
+  111: 'JO'
+  112: 'KZ'
+  113: 'KE'
+  114: 'KI'
+  115: 'KO'
+  116: 'KW'
+  117: 'KG'
+  118: 'LA'
+  119: 'LV'
+  120: 'LB'
+  121: 'LS'
+  122: 'LR'
+  123: 'LY'
+  124: 'LI'
+  125: 'LT'
+  126: 'LU'
+  127: 'MO'
+  128: 'MK'
+  129: 'MG'
+  130: 'ME'
+  131: 'MW'
+  132: 'MY'
+  133: 'MV'
+  134: 'ML'
+  135: 'MT'
+  136: 'MH'
+  137: 'MQ'
+  138: 'MR'
+  139: 'MU'
+  140: 'YT'
+  141: 'MX'
+  142: 'FM'
+  143: 'MD'
+  144: 'MC'
+  145: 'MN'
+  146: 'MS'
+  147: 'MA'
+  148: 'MZ'
+  149: 'MM'
+  150: 'NA'
+  151: 'NR'
+  152: 'NP'
+  153: 'NL'
+  154: 'AN'
+  155: 'NT'
+  156: 'NC'
+  157: 'NZ'
+  158: 'NI'
+  159: 'NE'
+  160: 'NG'
+  161: 'NU'
+  162: 'NF'
+  163: 'KP'
+  164: 'NB'
+  165: 'MP'
+  166: 'NO'
+  167: 'OM'
+  168: 'PK'
+  169: 'PW'
+  170: 'PA'
+  171: 'PG'
+  172: 'PY'
+  173: 'PE'
+  174: 'PH'
+  175: 'PN'
+  176: 'PL'
+  177: 'PO'
+  178: 'PT'
+  179: 'PR'
+  180: 'QA'
+  181: 'RE'
+  182: 'RO'
+  183: 'RT'
+  184: 'RU'
+  185: 'RW'
+  186: 'SS'
+  187: 'KN'
+  188: 'LC'
+  189: 'VC'
+  190: 'SP'
+  191: 'WS'
+  192: 'SM'
+  193: 'ST'
+  194: 'SA'
+  195: 'SF'
+  196: 'SN'
+  197: 'SC'
+  198: 'SL'
+  199: 'SG'
+  200: 'SK'
+  201: 'SI'
+  202: 'SB'
+  203: 'SO'
+  204: 'ZA'
+  205: 'GS'
+  206: 'KR'
+  207: 'ES'
+  208: 'LK'
+  209: 'NT'
+  210: 'SW'
+  211: 'VI'
+  212: 'EU'
+  213: 'SH'
+  214: 'UV'
+  215: 'KN'
+  216: 'LC'
+  217: 'MB'
+  218: 'TB'
+  219: 'PM'
+  220: 'VL'
+  221: 'VC'
+  222: 'SD'
+  223: 'SR'
+  224: 'SJ'
+  225: 'SZ'
+  226: 'SE'
+  227: 'CH'
+  228: 'SY'
+  229: 'TA'
+  230: 'TW'
+  231: 'TJ'
+  232: 'TZ'
+  233: 'TH'
+  234: 'TI'
+  235: 'TG'
+  236: 'TK'
+  237: 'TO'
+  238: 'TL'
+  239: 'TT'
+  240: 'TU'
+  241: 'TN'
+  242: 'TR'
+  243: 'TM'
+  244: 'TC'
+  245: 'TV'
+  246: 'UG'
+  247: 'UA'
+  248: 'UI'
+  249: 'AE'
+  251: 'UY'
+  252: 'UM'
+  253: 'SU'
+  254: 'UZ'
+  255: 'VU'
+  256: 'VA'
+  257: 'VE'
+  258: 'VN'
+  259: 'VR'
+  260: 'VG'
+  261: 'VI'
+  262: 'WL'
+  263: 'WF'
+  264: 'WS'
+  265: 'YA'
+  266: 'YE'
+  267: 'YU'
+  268: 'ZR'
+  269: 'ZM'
+  270: 'ZW'
+  271: 'RS'