intercom 1.0.0 → 2.0.0

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,22 @@
+module Intercom
+  module ApiOperations
+    module Find
+      module ClassMethods
+        def find(params)
+          raise BadRequestError, "#{self}#find takes a hash as it's 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
+          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 it's 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,15 @@
+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
+        from_response(response)
+      end
+    end
+  end
+end

data/lib/intercom/api_operations/save.rb

@@ -0,0 +1,44 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  module ApiOperations
+    module Save
+
+      module ClassMethods
+        def create(params)
+          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
+
+      private
+
+      def id_present?
+        id && id.to_s != ''
+      end
+
+      def posted_updates?
+        respond_to?(:update_verb) && update_verb == 'post'
+      end
+
+      def identity_hash
+        respond_to?(:identity_vars) ? to_hash.slice(*(identity_vars.map(&:to_s))) : {}
+      end
+    end
+  end
+end

data/lib/intercom/collection_proxy.rb

@@ -0,0 +1,66 @@
+require "intercom/utils"
+require "ext/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
+        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')
+      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 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

data/lib/intercom/company.rb

@@ -0,0 +1,29 @@
+require 'intercom/api_operations/count'
+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/load'
+require 'intercom/extended_api_operations/users'
+require 'intercom/extended_api_operations/tags'
+require 'intercom/traits/incrementable_attributes'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Company
+    include ApiOperations::Count
+    include ApiOperations::List
+    include ApiOperations::Find
+    include ApiOperations::FindAll
+    include ApiOperations::Save
+    include ApiOperations::Load
+    include ExtendedApiOperations::Users
+    include ExtendedApiOperations::Tags
+    include Traits::IncrementableAttributes
+    include Traits::ApiResource
+
+    def identity_vars ; [:id, :company_id] ; end
+    def flat_store_attributes ; [:custom_attributes] ; end
+    def update_verb ; 'post' ; end
+  end
+end

data/lib/intercom/conversation.rb

@@ -0,0 +1,15 @@
+require 'intercom/extended_api_operations/reply'
+require 'intercom/api_operations/find_all'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/load'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Conversation
+    include ExtendedApiOperations::Reply
+    include ApiOperations::FindAll
+    include ApiOperations::Find
+    include ApiOperations::Load
+    include Traits::ApiResource
+  end
+end

data/lib/intercom/count.rb

@@ -0,0 +1,21 @@
+require 'intercom/traits/api_resource'
+require 'intercom/api_operations/find'
+require 'intercom/traits/generic_handler_binding'
+require 'intercom/generic_handlers/count'
+
+module Intercom
+  class Count
+    include ApiOperations::Find
+    include Traits::ApiResource
+    include Traits::GenericHandlerBinding
+    include GenericHandlers::Count
+
+    def self.fetch_for_app
+      Intercom::Count.find({})
+    end
+
+    def self.fetch_broken_down_count(entity_to_count, count_context)
+      Intercom::Count.find(:type => entity_to_count, :count => count_context)
+    end
+  end
+end

data/lib/intercom/errors.rb

@@ -0,0 +1,52 @@
+module Intercom
+
+  # Base class exception from which all public Intercom exceptions will be derived
+  class IntercomError < StandardError
+    attr_reader :http_code, :application_error_code
+    def initialize(message, http_code: nil, application_error_code: application_error_code)
+      @http_code = http_code
+      @application_error_code = application_error_code
+      super(message)
+    end
+  end
+
+  # Raised when the credentials you provide don't match a valid account on Intercom.
+  # Check that you have set <b>Intercom.app_id=</b> and <b>Intercom.app_api_key=</b> correctly.
+  class AuthenticationError < IntercomError; end
+
+  # Raised when something does wrong on within the Intercom API service.
+  class ServerError < IntercomError; end
+
+  # Raised when we have bad gateway errors.
+  class BadGatewayError < IntercomError; end
+
+  # Raised when we reach socket connect timeout
+  class ServiceUnavailableError < IntercomError; end
+
+  # Raised when requesting resources on behalf of a user that doesn't exist in your application on Intercom.
+  class ResourceNotFound < IntercomError; end
+
+  # Raised when the request has a bad syntax
+  class BadRequestError < IntercomError; end
+
+  # Raised when you have exceed the API rate limit
+  class RateLimitExceeded < IntercomError; end
+
+  # Raised when the request throws an error not accounted for
+  class UnexpectedError < IntercomError; end
+
+  # Raised when you try to call a non-setter method that does not exist on an object
+  class Intercom::AttributeNotSetError < IntercomError ; end
+
+  #
+  # Non-public errors (internal to the gem)
+  #
+
+  # Base class exception from which all public Intercom exceptions will be derived
+  class IntercomInternalError < StandardError; end
+
+  # Raised when we attempt to handle a method missing but are unsuccessful
+  class Intercom::NoMethodMissingHandler < IntercomInternalError; end
+
+  class Intercom::DeserializationError < IntercomInternalError; end
+end

data/lib/intercom/event.rb

@@ -1,106 +1,9 @@
-require 'intercom/requires_parameters'
-require 'intercom/hashable_object'
-
+require 'intercom/api_operations/save'
+require 'intercom/traits/api_resource'
 
 module Intercom
-  
-  ##
-  # Represents an Event
-  #
-  # An event consists of an event_name and a user the event applies to. The user is identified via email or id.
-  # Additionally, a created timestamp is required.
-  #
-  # == Examples
-  #
-  #  event = Intercom::Event.create(:event_name => "post", :user => current_user, :created_at => Time.now)
-  #
-  #  You can also create an user-event and save it like this:
-  #  event = Intercom::Event.new
-  #  event.event_name = "publish-post"
-  #  event.user = current_user
-  #  event.created_at = Time.now
-  #  event.metadata = {
-  #   :title => 'Gravity Review',
-  #   :link => 'https://example.org/posts/22',
-  #   :comments => 'https://example.org/posts/22/comments'
-  # }
-  #  event.save
-  #
-  # == Batch
-  #
-  # Events can be created in batches, and sent as one request. To do some, create events
-  # without calling .create, as follows:
-  # 
-  # event = Intercom::Event.new
-  # event.event_name = "publish-post"
-  # event.user = current_user
-  #
-  # Then pass them to the save_batch_events class method, along with an (optional) default user:
-  #
-  # Intercom::Event.save_batch_events(events, default_user)
-  #
-  # Any events without a user will be assigned to the default_user.
-  #
-  # Note: if you do not supply a created time, the current time in UTC will be used. Events that have the same 
-  # user, name, and created time (to second granularity) may be treated as duplicates by the server.
-  
   class Event
-    extend RequiresParameters
-    include HashableObject
-    
-    attr_accessor :event_name, :user, :created_at # required
-    attr_accessor :metadata, :type
-    
-    def initialize(attributes={})
-      from_hash(attributes)
-    end
-    
-    ##
-    # Creates a new Event using params and saves it
-    # @see #save
-    def self.create(params)
-      params[:created_at] ||= Time.now
-      requires_parameters(params, %W(event_name user created_at))
-      Event.new(params).save
-    end
-        
-    ##
-    # Save the Event
-    def save
-      raise ArgumentError.new("Missing User") if user.nil?
-      Event.save_batch_events([self])
-      self
-    end
-    
-    ##
-    # Save a list of Events, with an optional base_user
-    def self.save_batch_events(events, base_user=nil)
-      hash = { :type => 'event.list', :data => []}
-      hash[:user] = user_hash(base_user) if base_user
-      events.each do |event|
-        hash[:data] << event.event_hash
-      end
-      post_to_intercom(hash)
-    end
-    
-    def self.user_hash(user)
-      user.user_id ? { :user_id => user.user_id } : { :email => user.email }
-    end
-
-    def self.post_to_intercom(hash)
-      Intercom.post('/events', hash)
-    end
-        
-    def user_hash
-      Event.user_hash(user)
-    end
-    
-    def event_hash
-      event = { :event_name => event_name, :created => created_at.nil? ?  Time.now.utc.to_i : created_at.to_i }
-      event[:type] = type.nil? ? 'event' : type
-      event[:user] = user_hash unless user.nil?
-      event[:metadata] = metadata unless metadata.nil?
-      event
-    end
+    include ApiOperations::Save
+    include Traits::ApiResource
   end
 end