cogniteev-intercom 2.5.4

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/contact.rb

@@ -0,0 +1,22 @@
+require 'intercom/api_operations/count'
+require 'intercom/api_operations/load'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/find_all'
+require 'intercom/api_operations/save'
+require 'intercom/api_operations/convert'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Contact
+    include ApiOperations::Load
+    include ApiOperations::Find
+    include ApiOperations::FindAll
+    include ApiOperations::Save
+    include ApiOperations::Convert
+    include Traits::ApiResource
+
+    def identity_vars ; [:email, :user_id] ; end
+    def flat_store_attributes ; [:custom_attributes] ; end
+    def update_verb; 'put' ; end
+  end
+end

data/lib/intercom/conversation.rb

@@ -0,0 +1,17 @@
+require 'intercom/extended_api_operations/reply'
+require 'intercom/api_operations/find_all'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/load'
+require 'intercom/api_operations/save'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Conversation
+    include ExtendedApiOperations::Reply
+    include ApiOperations::FindAll
+    include ApiOperations::Find
+    include ApiOperations::Load
+    include ApiOperations::Save
+    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,61 @@
+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, error_code = application_error_code)
+      @http_code = http_code
+      @application_error_code = 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 experience a socket read timeout
+  class ServiceUnavailableError < IntercomError; end
+
+  # Raised when we experience socket connect timeout
+  class ServiceConnectionError < 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 multiple users match the query (typically duplicate email addresses)
+  class MultipleMatchingUsersError < IntercomError; end
+
+  # Raised when you try to call a non-setter method that does not exist on an object
+  class Intercom::AttributeNotSetError < IntercomError ; end
+  
+  # Raised when unexpected nil returned from server
+  class Intercom::HttpError < 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

@@ -0,0 +1,11 @@
+require 'intercom/api_operations/save'
+require 'intercom/api_operations/find_all'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Event
+    include ApiOperations::FindAll
+    include ApiOperations::Save
+    include Traits::ApiResource
+  end
+end

data/lib/intercom/extended_api_operations/reply.rb

@@ -0,0 +1,16 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  module ExtendedApiOperations
+    module Reply
+
+      def reply(reply_data)
+        collection_name = Utils.resource_class_to_collection_name(self.class)
+        # TODO: For server, we should not need to merge in :conversation_id here (already in the URL)
+        response = Intercom.post("/#{collection_name}/#{id}/reply", reply_data.merge(:conversation_id => id))
+        from_response(response)
+      end
+
+    end
+  end
+end

data/lib/intercom/extended_api_operations/tags.rb

@@ -0,0 +1,14 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  module ExtendedApiOperations
+    module Tags
+
+      def tags
+        collection_name = Utils.resource_class_to_collection_name(self.class)
+        self.id ? Intercom::Tag.send("find_all_for_#{collection_name}", :id => id) : []
+      end
+
+    end
+  end
+end

data/lib/intercom/extended_api_operations/users.rb

@@ -0,0 +1,17 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  module ExtendedApiOperations
+    module Users
+
+      def users
+        collection_name = Utils.resource_class_to_collection_name(self.class)
+        finder_details = {}
+        finder_details[:url] = "/#{collection_name}/#{id}/users"
+        finder_details[:params] = {}
+        CollectionProxy.new("users", finder_details)
+      end
+
+    end
+  end
+end

data/lib/intercom/generic_handlers/base_handler.rb

@@ -0,0 +1,22 @@
+module Intercom
+  module GenericHandlers
+    class BaseHandler
+      attr_reader :method_sym, :arguments, :entity
+
+      def initialize(method_sym, arguments, entity)
+        @method_sym = method_sym
+        @arguments = arguments
+        @entity = entity
+      end
+
+      def method_string
+        method_sym.to_s
+      end
+
+      def raise_no_method_missing_handler
+        raise Intercom::NoMethodMissingHandler, "Could not handle '#{method_string}'"
+      end
+    end
+
+  end
+end

data/lib/intercom/generic_handlers/count.rb

@@ -0,0 +1,59 @@
+require 'intercom/generic_handlers/base_handler'
+
+module Intercom
+  module GenericHandlers
+    module Count
+      module ClassMethods
+        def generic_count(method_sym, *arguments, &block)
+
+          handler_class = Class.new(GenericHandlers::BaseHandler) do
+            def handle
+              match = method_string.match(GenericHandlers::Count.count_breakdown_matcher)
+              if match && match[1] && match[2] && match[3].nil?
+                do_broken_down_count(match[1], match[2])
+              elsif method_string.end_with? '_count'
+                return do_count
+              else
+                raise_no_method_missing_handler
+              end
+            end
+
+            private
+
+            def do_count
+              entity.fetch_for_app.send(appwide_entity_to_count)['count']
+            rescue Intercom::AttributeNotSetError
+              # Indicates this this kind of counting is not supported
+              raise_no_method_missing_handler
+            end
+
+            def do_broken_down_count(entity_to_count, count_context)
+              result = entity.fetch_broken_down_count(entity_to_count, count_context)
+              result.send(entity_to_count)[count_context]
+            rescue Intercom::BadRequestError => ex
+              # Indicates this this kind of counting is not supported
+              ex.application_error_code == 'parameter_invalid' ? raise_no_method_missing_handler : raise
+            end
+
+            def appwide_entity_to_count; method_string.gsub(/_count$/, ''); end
+          end
+
+          handler_class.new(method_sym, arguments, self).handle
+        end
+
+      end
+
+      def self.count_breakdown_matcher
+        /([[:alnum:]]+)_counts_for_each_([[:alnum:]]+)/
+      end
+
+      def self.handles_method?(method_sym)
+        method_sym.to_s.end_with? '_count' or method_sym.to_s.match(count_breakdown_matcher)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/intercom/generic_handlers/tag.rb

@@ -0,0 +1,71 @@
+require 'intercom/generic_handlers/base_handler'
+
+module Intercom
+  module GenericHandlers
+    module Tag
+      module ClassMethods
+        def generic_tag(method_sym, *arguments, &block)
+
+          handler_class = Class.new(GenericHandlers::BaseHandler) do
+            def handle
+              if method_string.start_with? 'tag_'
+                return do_tagging
+              elsif method_string.start_with? 'untag_'
+                return do_untagging
+              else
+                raise_no_method_missing_handler
+              end
+            end
+
+            private
+
+            def do_tagging
+              entity.create(:name => arguments[0], tagging_context.to_sym => tag_object_list(arguments))
+            end
+
+            def do_untagging
+              current_tag = find_tag(arguments[0])
+              return untag_via_save(current_tag) if current_tag
+            end
+
+            def find_tag(name_arg)
+              Intercom::Tag.find(:name => name_arg)
+            rescue Intercom::ResourceNotFound
+              return nil # Ignore if tag has since been deleted
+            end
+
+            def untag_via_save(current_tag)
+              current_tag.name = arguments[0]
+              current_tag.send("#{untagging_context}=", untag_object_list(arguments))
+              current_tag.save
+            end
+            
+            def tag_object_list(args)
+              args[1].map { |id| { :id => id } }
+            end
+            
+            def untag_object_list(args)
+              to_tag = tag_object_list(args)
+              to_tag.map { |tag_object| tag_object[:untag] = true }
+              to_tag
+            end
+
+            def tagging_context; method_string.gsub(/^tag_/, ''); end
+            def untagging_context; method_string.gsub(/^untag_/, ''); end
+          end
+
+          handler_class.new(method_sym, arguments, self).handle
+        end
+
+      end
+
+      def self.handles_method?(method_sym)
+        method_sym.to_s.start_with?('tag_') || method_sym.to_s.start_with?('untag_')
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/intercom/generic_handlers/tag_find_all.rb

@@ -0,0 +1,47 @@
+require 'intercom/generic_handlers/base_handler'
+
+module Intercom
+  module GenericHandlers
+    module TagFindAll
+      module ClassMethods
+        def generic_tag_find_all(method_sym, *arguments, &block)
+
+          handler_class = Class.new(GenericHandlers::BaseHandler) do
+            def handle
+              if method_string.start_with? 'find_all_for_'
+                return do_tag_find_all
+              else
+                raise_no_method_missing_handler
+              end
+            end
+
+            private
+
+            def do_tag_find_all
+              Intercom::Tag.find_all(cleaned_arguments.merge(:taggable_type => Utils.singularize(context)))
+            end
+
+            def cleaned_arguments
+              cleaned_args = arguments[0]
+              cleaned_args[:taggable_id] = cleaned_args.delete(:id) if cleaned_args.has_key?(:id)
+              cleaned_args
+            end
+
+            def context; method_string.gsub(/^find_all_for_/, ''); end
+          end
+
+          handler_class.new(method_sym, arguments, self).handle
+        end
+
+      end
+
+      def self.handles_method?(method_sym)
+        method_sym.to_s.start_with? 'find_all_for_'
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/intercom/lib/dynamic_accessors.rb

@@ -0,0 +1,59 @@
+module Intercom
+  module Lib
+    module DynamicAccessors
+
+      class << self
+
+        def define_accessors(attribute, value, object)
+          klass = object.class
+          if attribute.to_s.end_with?('_at') && attribute.to_s != 'update_last_request_at'
+            define_date_based_accessors(attribute, value, klass)
+          elsif object.flat_store_attribute?(attribute)
+            define_flat_store_based_accessors(attribute, value, klass)
+          else
+            define_standard_accessors(attribute, value, klass)
+          end
+        end
+
+        private
+
+        def define_flat_store_based_accessors(attribute, value, klass)
+          klass.class_eval %Q"
+            def #{attribute}=(value)
+              mark_field_as_changed!(:#{attribute})
+              @#{attribute} = Intercom::Lib::FlatStore.new(value)
+            end
+            def #{attribute}
+              @#{attribute}
+            end
+          "
+        end
+
+        def define_date_based_accessors(attribute, value, klass)
+          klass.class_eval %Q"
+            def #{attribute}=(value)
+              mark_field_as_changed!(:#{attribute})
+              @#{attribute} = value.nil? ? nil : value.to_i
+            end
+            def #{attribute}
+              @#{attribute}.nil? ? nil : Time.at(@#{attribute})
+            end
+          "
+        end
+
+        def define_standard_accessors(attribute, value, klass)
+            klass.class_eval %Q"
+              def #{attribute}=(value)
+                mark_field_as_changed!(:#{attribute})
+                @#{attribute} = value
+              end
+              def #{attribute}
+                @#{attribute}
+              end
+            "
+        end
+
+      end
+    end
+  end
+end