intercom 3.9.5 → 4.1.2

data/lib/intercom/note.rb

@@ -4,5 +4,9 @@ require 'intercom/traits/api_resource'
 module Intercom
   class Note
     include Traits::ApiResource
+
+    def self.collection_proxy_class
+      Intercom::BaseCollectionProxy
+    end
   end
 end

data/lib/intercom/request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cgi'
 require 'net/https'
 
@@ -23,17 +25,18 @@ module Intercom
       private def method_with_body(http_method, path, params)
         request = http_method.send(:new, path, default_headers)
         request.body = params.to_json
-        request["Content-Type"] = "application/json"
+        request['Content-Type'] = 'application/json'
         request
       end
 
       private def default_headers
-        {'Accept-Encoding' => 'gzip, deflate', 'Accept' => 'application/vnd.intercom.3+json', 'User-Agent' => "Intercom-Ruby/#{Intercom::VERSION}"}
+        { 'Accept-Encoding' => 'gzip, deflate', 'Accept' => 'application/vnd.intercom.3+json', 'User-Agent' => "Intercom-Ruby/#{Intercom::VERSION}" }
       end
 
       private def append_query_string_to_url(url, params)
         return url if params.empty?
-        query_string = params.map { |k, v| "#{k.to_s}=#{CGI::escape(v.to_s)}" }.join('&')
+
+        query_string = params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
         url + "?#{query_string}"
       end
     end
@@ -46,11 +49,11 @@ module Intercom
 
     attr_accessor :handle_rate_limit
 
-    def execute(target_base_url=nil, username:, secret: nil, read_timeout: 90, open_timeout: 30, api_version: nil)
+    def execute(target_base_url = nil, token:, read_timeout: 90, open_timeout: 30, api_version: nil)
       retries = 3
       base_uri = URI.parse(target_base_url)
       set_common_headers(net_http_method, base_uri)
-      set_basic_auth(net_http_method, username, secret)
+      set_auth_header(net_http_method, token)
       set_api_version(net_http_method, api_version) if api_version
       begin
         client(base_uri, read_timeout: read_timeout, open_timeout: open_timeout).start do |http|
@@ -71,7 +74,7 @@ module Intercom
             if @handle_rate_limit
               seconds_to_retry = (@rate_limit_details[:reset_at] - Time.now.utc).ceil
               if (retries -= 1) < 0
-                raise Intercom::RateLimitExceeded.new('Rate limit retries exceeded. Please examine current API Usage.')
+                raise Intercom::RateLimitExceeded, 'Rate limit retries exceeded. Please examine current API Usage.'
               else
                 sleep seconds_to_retry unless seconds_to_retry < 0
                 retry
@@ -80,11 +83,11 @@ module Intercom
               raise e
             end
           rescue Timeout::Error
-            raise Intercom::ServiceUnavailableError.new('Service Unavailable [request timed out]')
+            raise Intercom::ServiceUnavailableError, 'Service Unavailable [request timed out]'
           end
         end
       rescue Timeout::Error
-        raise Intercom::ServiceConnectionError.new('Failed to connect to service [connection attempt timed out]')
+        raise Intercom::ServiceConnectionError, 'Failed to connect to service [connection attempt timed out]'
       end
     end
 
@@ -114,8 +117,9 @@ module Intercom
     end
 
     private def decode(content_encoding, body)
-      return body if (!body) || body.empty? || content_encoding != 'gzip'
-      Zlib::GzipReader.new(StringIO.new(body)).read.force_encoding("utf-8")
+      return body if !body || body.empty? || content_encoding != 'gzip'
+
+      Zlib::GzipReader.new(StringIO.new(body)).read.force_encoding('utf-8')
     end
 
     private def json_parse_response(str, code)
@@ -123,7 +127,7 @@ module Intercom
 
       JSON.parse(str)
     rescue JSON::ParserError
-      msg = <<~MSG.gsub(/[[:space:]]+/, " ").strip # #squish from ActiveSuppor
+      msg = <<~MSG.gsub(/[[:space:]]+/, ' ').strip # #squish from ActiveSuppor
         Expected a JSON response body. Instead got '#{str}'
         with status code '#{code}'.
       MSG
@@ -139,12 +143,12 @@ module Intercom
       @rate_limit_details = rate_limit_details
     end
 
-    private def set_common_headers(method, base_uri)
+    private def set_common_headers(method, _base_uri)
       method.add_field('AcceptEncoding', 'gzip, deflate')
     end
 
-    private def set_basic_auth(method, username, secret)
-      method.basic_auth(CGI.unescape(username), CGI.unescape(secret))
+    private def set_auth_header(method, token)
+      method.add_field('Authorization', "Bearer #{token}")
     end
 
     private def set_api_version(method, api_version)
@@ -155,21 +159,21 @@ module Intercom
       code = res.code.to_i
 
       if code == 404
-        raise Intercom::ResourceNotFound.new('Resource Not Found')
+        raise Intercom::ResourceNotFound, 'Resource Not Found'
       elsif code == 401
-        raise Intercom::AuthenticationError.new('Unauthorized')
+        raise Intercom::AuthenticationError, 'Unauthorized'
       elsif code == 403
-        raise Intercom::AuthenticationError.new('Forbidden')
+        raise Intercom::AuthenticationError, 'Forbidden'
       elsif code == 429
-        raise Intercom::RateLimitExceeded.new('Rate Limit Exceeded')
+        raise Intercom::RateLimitExceeded, 'Rate Limit Exceeded'
       elsif code == 500
-        raise Intercom::ServerError.new('Server Error')
+        raise Intercom::ServerError, 'Server Error'
       elsif code == 502
-        raise Intercom::BadGatewayError.new('Bad Gateway Error')
+        raise Intercom::BadGatewayError, 'Bad Gateway Error'
       elsif code == 503
-        raise Intercom::ServiceUnavailableError.new('Service Unavailable')
+        raise Intercom::ServiceUnavailableError, 'Service Unavailable'
       elsif code == 504
-        raise Intercom::GatewayTimeoutError.new('Gateway Timeout')
+        raise Intercom::GatewayTimeoutError, 'Gateway Timeout'
       end
     end
 
@@ -180,10 +184,10 @@ module Intercom
       error_field = error_details['field']
       parsed_http_code = (http_code > 0 ? http_code : nil)
       error_context = {
-        :http_code => parsed_http_code,
-        :application_error_code => error_code,
-        :field => error_field,
-        :request_id => error_list_details['request_id']
+        http_code: parsed_http_code,
+        application_error_code: error_code,
+        field: error_field,
+        request_id: error_list_details['request_id']
       }
       case error_code
       when 'unauthorized', 'forbidden', 'token_not_found'
@@ -194,19 +198,19 @@ module Intercom
         raise Intercom::TokenRevokedError.new(error_details['message'], error_context)
       when 'token_unauthorized'
         raise Intercom::TokenUnauthorizedError.new(error_details['message'], error_context)
-      when "bad_request", "missing_parameter", 'parameter_invalid', 'parameter_not_found'
+      when 'bad_request', 'missing_parameter', 'parameter_invalid', 'parameter_not_found'
         raise Intercom::BadRequestError.new(error_details['message'], error_context)
-      when "not_restorable"
+      when 'not_restorable'
         raise Intercom::BlockedUserError.new(error_details['message'], error_context)
-      when "not_found", "company_not_found"
+      when 'not_found', 'company_not_found'
         raise Intercom::ResourceNotFound.new(error_details['message'], error_context)
-      when "admin_not_found"
+      when 'admin_not_found'
         raise Intercom::AdminNotFound.new(error_details['message'], error_context)
-      when "rate_limit_exceeded"
+      when 'rate_limit_exceeded'
         raise Intercom::RateLimitExceeded.new(error_details['message'], error_context)
-      when "custom_data_limit_reached"
+      when 'custom_data_limit_reached'
         raise Intercom::CDALimitReachedError.new(error_details['message'], error_context)
-      when "invalid_document"
+      when 'invalid_document'
         raise Intercom::InvalidDocumentError.new(error_details['message'], error_context)
       when 'service_unavailable'
         raise Intercom::ServiceUnavailableError.new(error_details['message'], error_context)

data/lib/intercom/scroll_collection_proxy.rb

@@ -1,32 +1,34 @@
-require "intercom/utils"
+# frozen_string_literal: true
 
-module Intercom
-  class ScrollCollectionProxy
+require 'intercom/utils'
+require 'intercom/base_collection_proxy'
 
-    attr_reader :resource_name, :scroll_url, :resource_class, :scroll_param, :records
+module Intercom
+  class ScrollCollectionProxy < BaseCollectionProxy
+    attr_reader :scroll_url, :scroll_param, :records
 
-    def initialize(resource_name, finder_details: {}, client:)
+    def initialize(resource_name, resource_class, details: {}, client:)
       @resource_name = resource_name
-      @resource_class = Utils.constantize_resource_name(resource_name)
-      @scroll_url = (finder_details[:url] || "/#{@resource_name}") + '/scroll'
+      @resource_class = resource_class
+      @scroll_url = (details[:url] || "/#{@resource_name}") + '/scroll'
       @client = client
-
     end
 
-    def next(scroll_parameter=nil)
+    def next(scroll_parameter = nil)
       @records = []
-      if not scroll_parameter
-        #First time so do initial get without scroll_param
-        response_hash = @client.get(@scroll_url, '')
-      else
-        #Not first call so use get next page
-        response_hash = @client.get(@scroll_url, scroll_param: scroll_parameter)
-      end
-      raise Intercom::HttpError.new('Http Error - No response entity returned') unless response_hash
+      response_hash = if !scroll_parameter
+                        # First time so do initial get without scroll_param
+                        @client.get(@scroll_url, '')
+                      else
+                        # Not first call so use get next page
+                        @client.get(@scroll_url, scroll_param: scroll_parameter)
+                      end
+      raise Intercom::HttpError, 'Http Error - No response entity returned' unless response_hash
+
       @scroll_param = extract_scroll_param(response_hash)
-      top_level_entity_key = deserialize_response_hash(response_hash)
+      top_level_entity_key = entity_key_from_response(response_hash)
       response_hash[top_level_entity_key] = response_hash[top_level_entity_key].map do |object_json|
-        Lib::TypedJsonDeserializer.new(object_json).deserialize
+        Lib::TypedJsonDeserializer.new(object_json, @client).deserialize
       end
       @records = response_hash[@resource_name]
       self
@@ -35,47 +37,41 @@ module Intercom
     def each(&block)
       scroll_param = nil
       loop do
-        if not scroll_param
-          response_hash = @client.get(@scroll_url, '')
-        else
-          response_hash = @client.get(@scroll_url, scroll_param: scroll_param)
-        end
-        raise Intercom::HttpError.new('Http Error - No response entity returned') unless response_hash
-        response_hash[deserialize_response_hash(response_hash)].each do |object_json|
-          block.call Lib::TypedJsonDeserializer.new(object_json).deserialize
+        response_hash = if !scroll_param
+                          @client.get(@scroll_url, '')
+                        else
+                          @client.get(@scroll_url, scroll_param: scroll_param)
+                        end
+        raise Intercom::HttpError, 'Http Error - No response entity returned' unless response_hash
+
+        top_level_entity_key = entity_key_from_response(response_hash)
+        response_hash[top_level_entity_key].each do |object_json|
+          block.call Lib::TypedJsonDeserializer.new(object_json, @client).deserialize
         end
         scroll_param = extract_scroll_param(response_hash)
-        break if not records_present?(response_hash)
+        break unless records_present?(response_hash)
       end
       self
     end
 
-    def [](target_index)
-      self.each_with_index do |item, index|
-        return item if index == target_index
-      end
-      nil
-    end
-
-    include Enumerable
-
     private
 
-    def deserialize_response_hash(response_hash)
-      top_level_type = response_hash.delete('type')
+    def entity_key_from_response(response_hash)
+      top_level_type = response_hash['type']
       if resource_name == 'subscriptions'
-        top_level_entity_key = 'items'
+        'items'
       else
-        top_level_entity_key = Utils.entity_key_from_type(top_level_type)
+        Utils.entity_key_from_type(top_level_type)
       end
     end
 
     def records_present?(response_hash)
-      (response_hash[@resource_name].length > 0)
+      !response_hash[entity_key_from_response(response_hash)].empty?
     end
 
     def extract_scroll_param(response_hash)
       return nil unless records_present?(response_hash)
+
       response_hash['scroll_param']
     end
   end

data/lib/intercom/search_collection_proxy.rb

@@ -1,82 +1,47 @@
-require "intercom/utils"
+# frozen_string_literal: true
 
-module Intercom
-  class SearchCollectionProxy
-
-    attr_reader :resource_name, :resource_class
-
-    def initialize(resource_name, search_details: {}, client:)
-      @resource_name = resource_name
-      @resource_class = Utils.constantize_resource_name(resource_name)
-      @search_url = search_details[:url]
-      @search_params = search_details[:params]
-      @client = client
-    end
-
-    def each(&block)
-      loop do
-        response_hash = @client.post(@search_url, payload)
-        raise Intercom::HttpError.new('Http Error - No response entity returned') unless response_hash
-        deserialize_response_hash(response_hash, block)
-        break unless has_next_link?(response_hash)
-      end
-      self
-    end
+require 'intercom/utils'
+require 'intercom/base_collection_proxy'
 
-    def [](target_index)
-      self.each_with_index do |item, index|
-        return item if index == target_index
-      end
-      nil
+module Intercom
+  class SearchCollectionProxy < BaseCollectionProxy
+    def initialize(resource_name, resource_class, details: {}, client:)
+      super(resource_name, resource_class, details: details, client: client, method: 'post')
     end
 
-    include Enumerable
-
     private
 
-    def deserialize_response_hash(response_hash, block)
-      top_level_type = response_hash.delete('type')
-      top_level_entity_key = Utils.entity_key_from_type(top_level_type)
-      response_hash[top_level_entity_key].each do |object_json|
-        block.call Lib::TypedJsonDeserializer.new(object_json).deserialize
-      end
-    end
-
-    def has_next_link?(response_hash)
-      paging_info = response_hash.delete('pages')
-      paging_next = paging_info["next"]
-      if paging_next
-        @search_params[:starting_after] = paging_next["starting_after"]
-        return true
-      else
-        return false
-      end
-    end
-
     def payload
       payload = {
-        query: @search_params[:query]
+        query: @params[:query]
       }
-      if @search_params[:sort_field] || @search_params[:sort_order]
+      if sort_field || sort_order
         payload[:sort] = {}
-        if @search_params[:sort_field]
-          payload[:sort][:field] = @search_params[:sort_field]
-        end
-        if @search_params[:sort_order]
-          payload[:sort][:order] = @search_params[:sort_order]
-        end
+        payload[:sort][:field] = sort_field if sort_field
+        payload[:sort][:order] = sort_order if sort_order
       end
-      if @search_params[:per_page] || @search_params[:starting_after]
+      if per_page || starting_after
         payload[:pagination] = {}
-        if @search_params[:per_page]
-          payload[:pagination][:per_page] = @search_params[:per_page]
-        end
-        if @search_params[:starting_after]
-          payload[:pagination][:starting_after] = @search_params[:starting_after]
-        end
+        payload[:pagination][:per_page] = per_page if per_page
+        payload[:pagination][:starting_after] = starting_after if starting_after
       end
-      return payload
+      payload
+    end
+
+    def sort_field
+      @params[:sort_field]
     end
 
+    def sort_order
+      @params[:sort_order]
+    end
+
+    def per_page
+      @params[:per_page]
+    end
+
+    def starting_after
+      @params[:starting_after]
+    end
   end
 end

data/lib/intercom/section.rb

@@ -0,0 +1,23 @@
+require 'intercom/api_operations/list'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/save'
+require 'intercom/api_operations/delete'
+
+module Intercom
+  module Service
+    class Section < BaseService
+      include ApiOperations::List
+      include ApiOperations::Find
+      include ApiOperations::Save
+      include ApiOperations::Delete
+
+      def collection_class
+        Intercom::Section
+      end
+
+      def collection_name
+        'help_center/sections'
+      end
+    end
+  end
+end

data/lib/intercom/segment.rb

@@ -3,5 +3,9 @@ require 'intercom/traits/api_resource'
 module Intercom
   class Segment
     include Traits::ApiResource
+
+    def self.collection_proxy_class
+      Intercom::BaseCollectionProxy
+    end
   end
 end

data/lib/intercom/service/article.rb

@@ -0,0 +1,20 @@
+require 'intercom/service/base_service'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/list'
+require 'intercom/api_operations/delete'
+require 'intercom/api_operations/save'
+
+module Intercom
+  module Service
+    class Article < BaseService
+      include ApiOperations::Find
+      include ApiOperations::List
+      include ApiOperations::Delete
+      include ApiOperations::Save
+
+      def collection_class
+        Intercom::Article
+      end
+    end
+  end
+end