cogniteev-intercom 2.5.4

data/lib/ext/sliceable_hash.rb

@@ -0,0 +1,16 @@
+class SliceableHash
+ 
+  def initialize(hash)
+    @hash = hash
+  end
+
+  # Return a hash that includes only the given keys.
+  def slice(*keys)
+    keys.map! { |key| @hash.convert_key(key) } if @hash.respond_to?(:convert_key, true)
+    keys.each_with_object(@hash.class.new) { |k, hash| hash[k] = @hash[k] if @hash.has_key?(k) && if_string_not_empty(@hash[k]) }
+  end
+  
+  def if_string_not_empty(val)
+    val.kind_of?(String) ? !val.empty? : true
+  end
+end

data/lib/intercom.rb

@@ -0,0 +1,176 @@
+require "intercom/version"
+require "intercom/contact"
+require "intercom/user"
+require "intercom/company"
+require "intercom/note"
+require "intercom/tag"
+require "intercom/segment"
+require "intercom/event"
+require "intercom/conversation"
+require "intercom/message"
+require "intercom/admin"
+require "intercom/count"
+require "intercom/request"
+require "intercom/subscription"
+require "intercom/notification"
+require "intercom/utils"
+require "intercom/errors"
+require "json"
+
+##
+# Intercom is a customer relationship management and messaging tool for web app owners
+#
+# This library provides ruby bindings for the Intercom API (https://api.intercom.io)
+#
+# == Basic Usage
+# === Configure Intercom with your access credentials
+#   Intercom.app_id = "my_app_id"
+#   Intercom.app_api_key = "my_api_key"
+# === Make requests to the API
+#   Intercom::User.find(:email => "bob@example.com")
+#
+module Intercom
+  @hostname = "api.intercom.io"
+  @protocol = "https"
+
+  @endpoints = nil
+  @current_endpoint = nil
+  @app_id = nil
+  @app_api_key = nil
+  @rate_limit_details = {}
+
+  def self.app_id=(app_id)
+    @app_id = app_id
+  end
+
+  def self.app_id
+    @app_id
+  end
+
+  def self.app_api_key=(app_api_key)
+    @app_api_key = app_api_key
+  end
+
+  def self.app_api_key
+    @app_api_key
+  end
+
+  def self.rate_limit_details=(rate_limit_details)
+    @rate_limit_details = rate_limit_details
+  end
+
+  def self.rate_limit_details
+    @rate_limit_details
+  end
+
+  # This method is obsolete and used to warn of backwards incompatible changes on upgrading
+  def self.api_key=(val)
+    raise ArgumentError, "#{compatibility_warning_text} #{compatibility_workaround_text} #{related_docs_text}"
+  end
+
+  private
+
+  def self.target_base_url
+    raise ArgumentError, "#{configuration_required_text} #{related_docs_text}" if [@app_id, @app_api_key].any?(&:nil?)
+    basic_auth_part = "#{@app_id}:#{@app_api_key}@"
+    current_endpoint.gsub(/(https?:\/\/)(.*)/, "\\1#{basic_auth_part}\\2")
+  end
+
+  def self.related_docs_text
+    "See https://github.com/intercom/intercom-ruby for usage examples."
+  end
+
+  def self.compatibility_warning_text
+    "It looks like you are upgrading from an older version of the intercom-ruby gem. Please note that this new version (#{Intercom::VERSION}) is not backwards compatible. "
+  end
+
+  def self.compatibility_workaround_text
+    "To get rid of this error please set Intercom.app_api_key and don't set Intercom.api_key."
+  end
+
+  def self.configuration_required_text
+    "You must set both Intercom.app_id and Intercom.app_api_key to use this client."
+  end
+
+  def self.send_request_to_path(request)
+    request.execute(target_base_url)
+  rescue Intercom::ServiceUnavailableError => e
+    if endpoints.length > 1
+      retry_on_alternative_endpoint(request)
+    else
+      raise e
+    end
+  end
+
+  def self.retry_on_alternative_endpoint(request)
+    @current_endpoint = alternative_random_endpoint
+    request.execute(target_base_url)
+  end
+
+  def self.current_endpoint
+    return @current_endpoint if @current_endpoint && @endpoint_randomized_at > (Time.now - (60 * 5))
+    @endpoint_randomized_at = Time.now
+    @current_endpoint = random_endpoint
+  end
+
+  def self.random_endpoint
+    endpoints.shuffle.first
+  end
+
+  def self.alternative_random_endpoint
+    (endpoints.shuffle - [@current_endpoint]).first
+  end
+
+  def self.post(path, payload_hash)
+    send_request_to_path(Intercom::Request.post(path, payload_hash))
+  end
+
+  def self.delete(path, payload_hash)
+    send_request_to_path(Intercom::Request.delete(path, payload_hash))
+  end
+
+  def self.put(path, payload_hash)
+    send_request_to_path(Intercom::Request.put(path, payload_hash))
+  end
+
+  def self.get(path, params)
+    send_request_to_path(Intercom::Request.get(path, params))
+  end
+
+  def self.check_required_params(params, path=nil) #nodoc
+    return if path.eql?("users")
+    raise ArgumentError.new("Expected params Hash, got #{params.class}") unless params.is_a?(Hash)
+    raise ArgumentError.new("Either email or user_id must be specified") unless params.keys.any? { |key| %W(email user_id).include?(key.to_s) }
+  end
+
+  def self.protocol #nodoc
+    @protocol
+  end
+
+  def self.protocol=(override) #nodoc
+    @protocol = override
+  end
+
+  def self.hostname #nodoc
+    @hostname
+  end
+
+  def self.hostname=(override) #nodoc
+    @hostname = override
+  end
+
+  def self.endpoint=(endpoint) #nodoc
+    self.endpoints = [endpoint]
+    @current_endpoint = nil
+  end
+
+  def self.endpoints=(endpoints) #nodoc
+    @endpoints = endpoints
+    @current_endpoint = nil
+  end
+
+  def self.endpoints
+    @endpoints || ["#{@protocol}://#{hostname}"]
+  end
+
+end

data/lib/intercom/admin.rb

@@ -0,0 +1,9 @@
+require 'intercom/api_operations/list'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Admin
+    include ApiOperations::List
+    include Traits::ApiResource
+  end
+end

data/lib/intercom/api_operations/convert.rb

@@ -0,0 +1,19 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  module ApiOperations
+    module Convert
+      def convert(user)
+        from_response(
+          Intercom.post(
+            "/contacts/convert",
+            {
+              contact: { user_id: user_id },
+              user: user.identity_hash
+            }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/intercom/api_operations/count.rb

@@ -0,0 +1,16 @@
+module Intercom
+  module ApiOperations
+    module Count
+      module ClassMethods
+        def count
+          singular_resource_name = Utils.resource_class_to_singular_name(self)
+          Intercom::Count.send("#{singular_resource_name}_count")
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/intercom/api_operations/delete.rb

@@ -0,0 +1,15 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  module ApiOperations
+    module Delete
+
+      def delete
+        collection_name = Utils.resource_class_to_collection_name(self.class)
+        Intercom.delete("/#{collection_name}/#{id}", {})
+        self
+      end
+
+    end
+  end
+end

data/lib/intercom/api_operations/find.rb

@@ -0,0 +1,23 @@
+module Intercom
+  module ApiOperations
+    module Find
+      module ClassMethods
+        def find(params)
+          raise BadRequestError, "#{self}#find takes a hash as its parameter but you supplied #{params.inspect}" unless params.is_a? Hash
+          collection_name = Utils.resource_class_to_collection_name(self)
+          if params[:id]
+            response = Intercom.get("/#{collection_name}/#{params[:id]}", {})
+          else
+            response = Intercom.get("/#{collection_name}", params)
+          end
+          raise Intercom::HttpError.new('Http Error - No response entity returned') unless response
+          from_api(response)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/intercom/api_operations/find_all.rb

@@ -0,0 +1,33 @@
+require 'intercom/collection_proxy'
+
+module Intercom
+  module ApiOperations
+    module FindAll
+      module ClassMethods
+        def find_all(params)
+          raise BadRequestError, "#{self}#find takes a hash as its parameter but you supplied #{params.inspect}" unless params.is_a? Hash
+          collection_name = Utils.resource_class_to_collection_name(self)
+          finder_details = {}
+          if params[:id] && !type_switched_finder?(params)
+            finder_details[:url] = "/#{collection_name}/#{params[:id]}"
+            finder_details[:params] = {}
+          else
+            finder_details[:url] = "/#{collection_name}"
+            finder_details[:params] = params
+          end
+          CollectionProxy.new(collection_name, finder_details)
+        end
+
+        private
+
+        def type_switched_finder?(params)
+          params.include?(:type)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/intercom/api_operations/list.rb

@@ -0,0 +1,17 @@
+require 'intercom/collection_proxy'
+
+module Intercom
+  module ApiOperations
+    module List # TODO: Should we rename to All
+      module ClassMethods
+        def all
+          CollectionProxy.new(Utils.resource_class_to_collection_name(self))
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/intercom/api_operations/load.rb

@@ -0,0 +1,16 @@
+module Intercom
+  module ApiOperations
+    module Load
+      def load
+        collection_name = Utils.resource_class_to_collection_name(self.class)
+        if id
+          response = Intercom.get("/#{collection_name}/#{id}", {})
+        else
+          raise "Cannot load #{self.class} as it does not have a valid id."
+        end
+        raise Intercom::HttpError.new('Http Error - No response entity returned') unless response
+        from_response(response)
+      end
+    end
+  end
+end

data/lib/intercom/api_operations/save.rb

@@ -0,0 +1,51 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  module ApiOperations
+    module Save
+
+      module ClassMethods
+        PARAMS_NOT_PROVIDED = Object.new
+        def create(params = PARAMS_NOT_PROVIDED)
+          if self.ancestors.include?(Intercom::Contact) && params == PARAMS_NOT_PROVIDED
+            params = Hash.new
+          elsif params == PARAMS_NOT_PROVIDED
+            raise ArgumentError, '.create requires 1 parameter'
+          end
+
+          instance = self.new(params)
+          instance.mark_fields_as_changed!(params.keys)
+          instance.save
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def save
+        collection_name = Utils.resource_class_to_collection_name(self.class)
+        if id_present? && !posted_updates?
+          response = Intercom.put("/#{collection_name}/#{id}", to_submittable_hash)
+        else
+          response = Intercom.post("/#{collection_name}", to_submittable_hash.merge(identity_hash))
+        end
+        from_response(response) if response # may be nil we received back a 202
+      end
+
+      def identity_hash
+        respond_to?(:identity_vars) ? SliceableHash.new(to_hash).slice(*(identity_vars.map(&:to_s))) : {}
+      end
+
+      private
+
+      def id_present?
+        id && id.to_s != ''
+      end
+
+      def posted_updates?
+        respond_to?(:update_verb) && update_verb == 'post'
+      end
+    end
+  end
+end

data/lib/intercom/collection_proxy.rb

@@ -0,0 +1,71 @@
+require "intercom/utils"
+require "ext/sliceable_hash"
+
+module Intercom
+  class CollectionProxy
+
+    attr_reader :resource_name
+
+    def initialize(resource_name, finder_details = {})
+      @resource_name = resource_name
+      @resource_class = Utils.constantize_resource_name(resource_name)
+      @finder_url = (finder_details[:url] || "/#{@resource_name}")
+      @finder_params = (finder_details[:params] || {})
+    end
+
+    def each(&block)
+      next_page = nil
+      loop do
+        if next_page
+          response_hash = Intercom.get(next_page, {})
+        else
+          response_hash = Intercom.get(@finder_url, @finder_params)
+        end
+        raise Intercom::HttpError.new('Http Error - No response entity returned') unless response_hash
+        deserialize_response_hash(response_hash, block)
+        next_page = extract_next_link(response_hash)
+        break if next_page.nil?
+      end
+      self
+    end
+
+    def [](target_index)
+      self.each_with_index do |item, index|
+        return item if index == target_index
+      end
+      nil
+    end
+
+    include Enumerable
+
+    def count
+      raise NoMethodError, "undefined method `count' for #{self.class}. Consider using the dedicated Intercom::Count interface if suitable"
+    end
+
+    private
+
+    def resource_class; @resource_class; end
+
+    def deserialize_response_hash(response_hash, block)
+      top_level_type = response_hash.delete('type')
+      if resource_name == 'subscriptions'
+        top_level_entity_key = 'items'
+      else
+        top_level_entity_key = Utils.entity_key_from_type(top_level_type)
+      end
+      response_hash[top_level_entity_key].each do |object_json|
+        block.call Lib::TypedJsonDeserializer.new(object_json).deserialize
+      end
+    end
+
+    def paging_info_present?(response_hash)
+      !!(response_hash['pages'] && response_hash['pages']['type'])
+    end
+
+    def extract_next_link(response_hash)
+      return nil unless paging_info_present?(response_hash)
+      paging_info = response_hash.delete('pages')
+      paging_info["next"]
+    end
+  end
+end