intercom 3.9.4 → 4.0.0

data/lib/intercom/lib/typed_json_deserializer.rb

@@ -1,54 +1,59 @@
+# frozen_string_literal: true
+
 require 'intercom/utils'
 
 module Intercom
   module Lib
-      # Responsibility: To decide whether we are deserializing a collection or an
-      # entity of a particular type and to dispatch deserialization
-      class TypedJsonDeserializer
-        attr_reader :json
-
-        def initialize(json)
-          @json = json
-        end
+    # Responsibility: To decide whether we are deserializing a collection or an
+    # entity of a particular type and to dispatch deserialization
+    class TypedJsonDeserializer
+      attr_reader :json
+
+      def initialize(json, client)
+        @json = json
+        @client = client
+      end
 
-        def deserialize
-          if blank_object_type?(object_type)
-            raise DeserializationError, "No type field was found to facilitate deserialization"
-          elsif list_object_type?(object_type)
-            deserialize_collection(json[object_entity_key])
-          else # singular object type
-            deserialize_object(json)
-          end
+      def deserialize
+        if blank_object_type?(object_type)
+          raise DeserializationError, 'No type field was found to facilitate deserialization'
+        elsif list_object_type?(object_type)
+          deserialize_collection(json[object_entity_key])
+        else # singular object type
+          deserialize_object(json)
         end
+      end
 
-        private
+      private
 
-        def blank_object_type?(object_type)
-          object_type.nil? || object_type == ''
-        end
+      def blank_object_type?(object_type)
+        object_type.nil? || object_type == ''
+      end
 
-        def list_object_type?(object_type)
-          object_type.end_with?('.list')
-        end
+      def list_object_type?(object_type)
+        object_type.end_with?('.list')
+      end
 
-        def deserialize_collection(collection_json)
-          return [] if collection_json == nil
-          collection_json.map { |item_json| TypedJsonDeserializer.new(item_json).deserialize }
-        end
+      def deserialize_collection(collection_json)
+        return [] if collection_json.nil?
 
-        def deserialize_object(object_json)
-          entity_class = Utils.constantize_singular_resource_name(object_entity_key)
-          entity_class.from_api(object_json)
-        end
+        collection_json.map { |item_json| TypedJsonDeserializer.new(item_json, @client).deserialize }
+      end
 
-        def object_type
-          @object_type ||= json['type']
-        end
+      def deserialize_object(object_json)
+        entity_class = Utils.constantize_singular_resource_name(object_entity_key)
+        deserialized = entity_class.from_api(object_json)
+        deserialized.client = @client
+        deserialized
+      end
 
-        def object_entity_key
-          @object_entity_key ||= Utils.entity_key_from_type(object_type)
-        end
+      def object_type
+        @object_type ||= json['type']
+      end
 
+      def object_entity_key
+        @object_entity_key ||= Utils.entity_key_from_type(object_type)
       end
+    end
   end
 end

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)
       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,40 @@ 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 = 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
+
         response_hash[deserialize_response_hash(response_hash)].each do |object_json|
-          block.call Lib::TypedJsonDeserializer.new(object_json).deserialize
+          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')
       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[@resource_name].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/service/base_service.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'intercom/client_collection_proxy'
 
 module Intercom
@@ -17,8 +19,13 @@ module Intercom
         Intercom::ClientCollectionProxy
       end
 
+      def collection_name
+        @collection_name ||= Utils.resource_class_to_collection_name(collection_class)
+      end
+
       def from_api(api_response)
         object = collection_class.new
+        object.client = @client
         object.from_response(api_response)
         object
       end

data/lib/intercom/service/company.rb

@@ -23,18 +23,6 @@ module Intercom
       def collection_class
         Intercom::Company
       end
-
-      def users_by_intercom_company_id(id)
-        get_users(url: "/companies/#{id}/users")
-      end
-
-      def users_by_company_id(id)
-        get_users(url: "/companies", params: { company_id: id, type: "user" })
-      end
-
-      private def get_users(url:, params: {})
-        ClientCollectionProxy.new("users", finder_details: { url: url, params: params }, client: @client)
-      end
     end
   end
 end

data/lib/intercom/service/contact.rb

@@ -2,12 +2,9 @@ require 'intercom/service/base_service'
 require 'intercom/api_operations/load'
 require 'intercom/api_operations/list'
 require 'intercom/api_operations/find'
-require 'intercom/api_operations/find_all'
 require 'intercom/api_operations/save'
-require 'intercom/api_operations/scroll'
-require 'intercom/api_operations/convert'
-require 'intercom/api_operations/archive'
-require 'intercom/api_operations/request_hard_delete'
+require 'intercom/api_operations/delete'
+require 'intercom/api_operations/search'
 
 module Intercom
   module Service
@@ -15,16 +12,30 @@ module Intercom
       include ApiOperations::Load
       include ApiOperations::List
       include ApiOperations::Find
-      include ApiOperations::FindAll
       include ApiOperations::Save
-      include ApiOperations::Scroll
-      include ApiOperations::Convert
-      include ApiOperations::Archive
-      include ApiOperations::RequestHardDelete
+      include ApiOperations::Delete
+      include ApiOperations::Search
 
       def collection_class
         Intercom::Contact
       end
+
+      def collection_proxy_class
+        Intercom::BaseCollectionProxy
+      end
+
+      def merge(lead, user)
+        raise_invalid_merge_error unless lead.role == 'lead' && user.role == 'user'
+
+        response = @client.post('/contacts/merge', from: lead.id, into: user.id)
+        raise Intercom::HttpError, 'Http Error - No response entity returned' unless response
+
+        user.from_response(response)
+      end
+
+      private def raise_invalid_merge_error
+        raise Intercom::InvalidMergeError, 'Merging can only be performed on a lead into a user'
+      end
     end
   end
 end

data/lib/intercom/service/conversation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'intercom/service/base_service'
 require 'intercom/api_operations/find_all'
 require 'intercom/api_operations/find'
@@ -13,6 +15,7 @@ module Intercom
       include ApiOperations::Find
       include ApiOperations::Load
       include ApiOperations::Save
+      include ApiOperations::Search
 
       def collection_class
         Intercom::Conversation
@@ -25,7 +28,7 @@ module Intercom
       def reply(reply_data)
         id = reply_data.delete(:id)
         collection_name = Utils.resource_class_to_collection_name(collection_class)
-        response = @client.post("/#{collection_name}/#{id}/reply", reply_data.merge(:conversation_id => id))
+        response = @client.post("/#{collection_name}/#{id}/reply", reply_data.merge(conversation_id: id))
         collection_class.new.from_response(response)
       end
 
@@ -44,14 +47,20 @@ module Intercom
       end
 
       def snooze(reply_data)
-        snoozed_until = reply_data.fetch(:snoozed_until) { fail 'snoozed_until field is required' }
+        reply_data.fetch(:snoozed_until) { raise 'snoozed_until field is required' }
         reply reply_data.merge(message_type: 'snoozed', type: 'admin')
       end
 
       def assign(reply_data)
-        assignee_id = reply_data.fetch(:assignee_id) { fail 'assignee_id is required' }
+        assignee_id = reply_data.fetch(:assignee_id) { raise 'assignee_id is required' }
         reply reply_data.merge(message_type: 'assignment', assignee_id: assignee_id, type: 'admin')
       end
+
+      def run_assignment_rules(id)
+        collection_name = Utils.resource_class_to_collection_name(collection_class)
+        response = @client.post("/#{collection_name}/#{id}/run_assignment_rules")
+        collection_class.new.from_response(response)
+      end
     end
   end
 end

data/lib/intercom/service/data_attribute.rb

@@ -0,0 +1,20 @@
+require 'intercom/service/base_service'
+require 'intercom/api_operations/load'
+require 'intercom/api_operations/list'
+require 'intercom/api_operations/find_all'
+require 'intercom/api_operations/save'
+
+module Intercom
+  module Service
+    class DataAttribute < BaseService
+      include ApiOperations::Load
+      include ApiOperations::List
+      include ApiOperations::FindAll
+      include ApiOperations::Save
+
+      def collection_class
+        Intercom::DataAttribute
+      end
+    end
+  end
+end