cogniteev-intercom 2.5.4

data/lib/intercom/lib/dynamic_accessors_on_method_missing.rb

@@ -0,0 +1,53 @@
+module Intercom
+  module Lib
+    class DynamicAccessorsOnMethodMissing
+
+      attr_reader :method_sym, :method_string, :arguments, :object, :klass
+
+      def initialize(method_sym, *arguments, object)
+        @method_sym = method_sym
+        @method_string = method_sym.to_s
+        @arguments = arguments
+        @klass = object.class
+        @object = object
+      end
+
+      def define_accessors_or_call(&block)
+        return yield if not_an_accessor?
+        if setter?
+          Lib::DynamicAccessors.define_accessors(attribute_name, *arguments, object)
+          object.send(method_sym, *arguments)
+        else # getter
+          if trying_to_access_private_variable?
+            yield
+          else
+            raise Intercom::AttributeNotSetError, attribute_not_set_error_message
+          end
+        end
+      end
+
+      private
+
+      def not_an_accessor?
+        (method_string.end_with? '?') || (method_string.end_with? '!') || arguments.length > 1
+      end
+
+      def setter?
+        method_string.end_with? '='
+      end
+
+      def attribute_name
+        method_string.gsub(/=$/, '')
+      end
+
+      def trying_to_access_private_variable?
+        object.instance_variable_defined?("@#{method_string}")
+      end
+
+      def attribute_not_set_error_message
+        "'#{method_string}' called on #{klass} but it has not been set an " +
+        "attribute or does not exist as a method"
+      end
+    end
+  end
+end

data/lib/intercom/lib/flat_store.rb

@@ -0,0 +1,31 @@
+module Intercom
+  module Lib
+
+    # Sub-class of {Hash} for storing custom data attributes.
+    # Doesn't allow nested Hashes or Arrays. And requires {String} or {Symbol} keys.
+    class FlatStore < Hash
+
+      def initialize(attributes={})
+        (attributes).each do |key, value|
+          validate_key_and_value(key, value)
+          self[key] = value
+        end
+      end
+
+      def []=(key, value)
+        validate_key_and_value(key, value)
+        super(key.to_s, value)
+      end
+
+      def [](key)
+        super(key.to_s)
+      end
+
+      private
+      def validate_key_and_value(key, value)
+        raise ArgumentError.new("This does not support nested data structures (key: #{key}, value: #{value}") if value.is_a?(Array) || value.is_a?(Hash)
+        raise ArgumentError.new("Key must be String or Symbol: #{key}") unless key.is_a?(String) || key.is_a?(Symbol)
+      end
+    end
+  end
+end

data/lib/intercom/lib/typed_json_deserializer.rb

@@ -0,0 +1,53 @@
+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
+
+        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
+
+        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 deserialize_collection(collection_json)
+          return [] if collection_json == nil
+          collection_json.map { |item_json| TypedJsonDeserializer.new(item_json).deserialize }
+        end
+
+        def deserialize_object(object_json)
+          entity_class = Utils.constantize_singular_resource_name(object_entity_key)
+          entity_class.from_api(object_json)
+        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/message.rb

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

data/lib/intercom/note.rb

@@ -0,0 +1,17 @@
+require 'intercom/api_operations/save'
+require 'intercom/api_operations/list'
+require 'intercom/api_operations/find_all'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/load'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Note
+    include ApiOperations::Save
+    include ApiOperations::List
+    include ApiOperations::FindAll
+    include ApiOperations::Find
+    include ApiOperations::Load
+    include Traits::ApiResource
+  end
+end

data/lib/intercom/notification.rb

@@ -0,0 +1,20 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Notification
+    include Traits::ApiResource
+
+    def model
+      data.item
+    end
+
+    def model_type
+      model.class
+    end
+
+    def load
+      model.load
+    end
+
+  end
+end

data/lib/intercom/request.rb

@@ -0,0 +1,166 @@
+require 'cgi'
+require 'net/https'
+
+module Intercom
+  class Request
+    attr_accessor :path, :net_http_method
+
+    def initialize(path, net_http_method)
+      self.path = path
+      self.net_http_method = net_http_method
+    end
+
+    def set_common_headers(method, base_uri)
+      method.basic_auth(CGI.unescape(base_uri.user), CGI.unescape(base_uri.password))
+      method.add_field('AcceptEncoding', 'gzip, deflate')
+    end
+
+    def self.get(path, params)
+      new(path, Net::HTTP::Get.new(append_query_string_to_url(path, params), default_headers))
+    end
+
+    def self.post(path, form_data)
+      new(path, method_with_body(Net::HTTP::Post, path, form_data))
+    end
+
+    def self.delete(path, params)
+      new(path, method_with_body(Net::HTTP::Delete, path, params))
+    end
+
+    def self.put(path, form_data)
+      new(path, method_with_body(Net::HTTP::Put, path, form_data))
+    end
+
+    def self.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
+    end
+
+    def self.default_headers
+      {'Accept-Encoding' => 'gzip, deflate', 'Accept' => 'application/vnd.intercom.3+json', 'User-Agent' => "Intercom-Ruby/#{Intercom::VERSION}"}
+    end
+
+    def client(uri)
+      net = Net::HTTP.new(uri.host, uri.port)
+      if uri.is_a?(URI::HTTPS)
+        net.use_ssl = true
+        net.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        net.ca_file = File.join(File.dirname(__FILE__), '../data/cacert.pem')
+      end
+      net.read_timeout = 90
+      net.open_timeout = 30
+      net
+    end
+
+    def execute(target_base_url=nil)
+      base_uri = URI.parse(target_base_url)
+      set_common_headers(net_http_method, base_uri)
+      begin
+        client(base_uri).start do |http|
+          begin
+            response = http.request(net_http_method)
+            set_rate_limit_details(response)
+            decoded_body = decode_body(response)
+            parsed_body = parse_body(decoded_body, response)
+            raise_errors_on_failure(response)
+            parsed_body
+          rescue Timeout::Error
+            raise Intercom::ServiceUnavailableError.new('Service Unavailable [request timed out]')
+          end
+        end
+      rescue Timeout::Error
+        raise Intercom::ServiceConnectionError.new('Failed to connect to service [connection attempt timed out]')
+      end
+    end
+    
+    def decode_body(response)
+      decode(response['content-encoding'], response.body)
+    end
+
+    def parse_body(decoded_body, response)
+      parsed_body = nil
+      return parsed_body if decoded_body.nil? || decoded_body.strip.empty?
+      begin
+        parsed_body = JSON.parse(decoded_body)
+      rescue JSON::ParserError => _
+        raise_errors_on_failure(response)
+      end
+      raise_application_errors_on_failure(parsed_body, response.code.to_i) if parsed_body['type'] == 'error.list'
+      parsed_body
+    end
+
+    def set_rate_limit_details(response)
+      rate_limit_details = {}
+      rate_limit_details[:limit] = response['X-RateLimit-Limit'].to_i if response['X-RateLimit-Limit']
+      rate_limit_details[:remaining] = response['X-RateLimit-Remaining'].to_i if response['X-RateLimit-Remaining']
+      rate_limit_details[:reset_at] = Time.at(response['X-RateLimit-Reset'].to_i) if response['X-RateLimit-Reset']
+      Intercom.rate_limit_details = rate_limit_details
+    end
+
+    def decode(content_encoding, body)
+      return body if (!body) || body.empty? || content_encoding != 'gzip'
+      Zlib::GzipReader.new(StringIO.new(body)).read
+    end
+
+    def raise_errors_on_failure(res)
+      if res.code.to_i.eql?(404)
+        raise Intercom::ResourceNotFound.new('Resource Not Found')
+      elsif res.code.to_i.eql?(401)
+        raise Intercom::AuthenticationError.new('Unauthorized')
+      elsif res.code.to_i.eql?(403)
+        raise Intercom::AuthenticationError.new('Forbidden')
+      elsif res.code.to_i.eql?(500)
+        raise Intercom::ServerError.new('Server Error')
+      elsif res.code.to_i.eql?(502)
+        raise Intercom::BadGatewayError.new('Bad Gateway Error')
+      elsif res.code.to_i.eql?(503)
+        raise Intercom::ServiceUnavailableError.new('Service Unavailable')
+      end
+    end
+
+    def raise_application_errors_on_failure(error_list_details, http_code)
+      # Currently, we don't support multiple errors
+      error_details = error_list_details['errors'].first
+      error_code = error_details['type'] || error_details['code']
+      parsed_http_code = (http_code > 0 ? http_code : nil)
+      error_context = {
+        :http_code => parsed_http_code,
+        :application_error_code => error_code
+      }
+      case error_code
+      when 'unauthorized', 'forbidden'
+        raise Intercom::AuthenticationError.new(error_details['message'], error_context)
+      when "bad_request", "missing_parameter", 'parameter_invalid'
+        raise Intercom::BadRequestError.new(error_details['message'], error_context)
+      when "not_found"
+        raise Intercom::ResourceNotFound.new(error_details['message'], error_context)
+      when "rate_limit_exceeded"
+        raise Intercom::RateLimitExceeded.new(error_details['message'], error_context)
+      when 'service_unavailable'
+        raise Intercom::ServiceUnavailableError.new(error_details['message'], error_context)
+      when 'conflict'
+        raise Intercom::MultipleMatchingUsersError.new(error_details['message'], error_context)
+      when nil, ''
+        raise Intercom::UnexpectedError.new(message_for_unexpected_error_without_type(error_details, parsed_http_code), error_context)
+      else
+        raise Intercom::UnexpectedError.new(message_for_unexpected_error_with_type(error_details, parsed_http_code), error_context)
+      end
+    end
+
+    def message_for_unexpected_error_with_type(error_details, parsed_http_code)
+      "The error of type '#{error_details['type']}' is not recognized. It occurred with the message: #{error_details['message']} and http_code: '#{parsed_http_code}'. Please contact Intercom with these details."
+    end
+
+    def message_for_unexpected_error_without_type(error_details, parsed_http_code)
+      "An unexpected error occured. It occurred with the message: #{error_details['message']} and http_code: '#{parsed_http_code}'. Please contact Intercom with these details."
+    end
+
+    def self.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('&')
+      url + "?#{query_string}"
+    end
+  end
+end

data/lib/intercom/segment.rb

@@ -0,0 +1,14 @@
+require 'intercom/api_operations/count'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/save'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Segment
+    include ApiOperations::List
+    include ApiOperations::Find
+    include ApiOperations::Save
+    include ApiOperations::Count
+    include Traits::ApiResource
+  end
+end

data/lib/intercom/subscription.rb

@@ -0,0 +1,15 @@
+require 'intercom/api_operations/list'
+require 'intercom/api_operations/find_all'
+require 'intercom/api_operations/save'
+require 'intercom/api_operations/delete'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Subscription
+    include ApiOperations::List
+    include ApiOperations::Find
+    include ApiOperations::Save
+    include ApiOperations::Delete
+    include Traits::ApiResource
+  end
+end

data/lib/intercom/tag.rb

@@ -0,0 +1,23 @@
+require 'intercom/api_operations/count'
+require 'intercom/api_operations/save'
+require 'intercom/api_operations/list'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/find_all'
+require 'intercom/traits/api_resource'
+require 'intercom/traits/generic_handler_binding'
+require 'intercom/generic_handlers/tag'
+require 'intercom/generic_handlers/tag_find_all'
+
+module Intercom
+  class Tag
+    include ApiOperations::Count
+    include ApiOperations::Save
+    include ApiOperations::List
+    include ApiOperations::Find
+    include ApiOperations::FindAll
+    include Traits::ApiResource
+    include Traits::GenericHandlerBinding
+    include GenericHandlers::Tag
+    include GenericHandlers::TagFindAll
+  end
+end

data/lib/intercom/traits/api_resource.rb

@@ -0,0 +1,132 @@
+require 'intercom/lib/flat_store'
+require 'intercom/lib/dynamic_accessors'
+require 'intercom/lib/dynamic_accessors_on_method_missing'
+require 'intercom/traits/dirty_tracking'
+require 'intercom/lib/typed_json_deserializer'
+
+module Intercom
+  module Traits
+
+    module ApiResource
+      include DirtyTracking
+
+      attr_accessor :id
+
+      def initialize(attributes = {})
+        from_hash(attributes)
+      end
+
+      def from_response(response)
+        from_hash(response)
+        reset_changed_fields!
+        self
+      end
+
+      def from_hash(hash)
+        hash.each do |attribute, value|
+          next if type_field?(attribute)
+          initialize_property(attribute, value)
+        end
+        initialize_missing_flat_store_attributes if respond_to? :flat_store_attributes
+        self
+      end
+
+      def to_hash
+        instance_variables_excluding_dirty_tracking_field.inject({}) do |hash, variable|
+          hash[variable.to_s.delete("@")] = instance_variable_get(variable)
+          hash
+        end
+      end
+
+      def to_submittable_hash
+        submittable_hash = {}
+        to_hash.each do |attribute, value|
+          submittable_hash[attribute] = value if submittable_attribute?(attribute, value)
+        end
+        submittable_hash
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        Lib::DynamicAccessorsOnMethodMissing.new(method_sym, *arguments, self).
+          define_accessors_or_call { super }
+      end
+
+      def flat_store_attribute?(attribute)
+        (respond_to?(:flat_store_attributes)) && (flat_store_attributes.map(&:to_s).include?(attribute.to_s))
+      end
+
+      private
+
+      def initialize_property(attribute, value)
+        Lib::DynamicAccessors.define_accessors(attribute, value, self) unless accessors_already_defined?(attribute)
+        set_property(attribute, value)
+      end
+
+      def accessors_already_defined?(attribute)
+        respond_to?(attribute) && respond_to?("#{attribute}=")
+      end
+
+      def set_property(attribute, value)
+        if typed_value?(value) && !custom_attribute_field?(attribute) && !message_from_field?(attribute, value) && !message_to_field?(attribute, value)
+          value_to_set = Intercom::Lib::TypedJsonDeserializer.new(value).deserialize
+        elsif flat_store_attribute?(attribute)
+          value_to_set = Intercom::Lib::FlatStore.new(value)
+        else
+          value_to_set = value
+        end
+        call_setter_for_attribute(attribute, value_to_set)
+      end
+
+      def custom_attribute_field?(attribute)
+        attribute == 'custom_attributes'
+      end
+      
+      def message_from_field?(attribute, value)
+        attribute.to_s == 'from' && value.is_a?(Hash) && value['type']
+      end
+      
+      def message_to_field?(attribute, value)
+        attribute.to_s == 'to' && value.is_a?(Hash) && value['type']
+      end
+
+      def typed_value?(value)
+        value.is_a? Hash and !!value['type']
+      end
+
+      def call_setter_for_attribute(attribute, value)
+        setter_method = "#{attribute.to_s}="
+        self.send(setter_method, value)
+      end
+
+      def type_field?(attribute)
+        attribute == 'type'
+      end
+
+      def initialize_missing_flat_store_attributes
+        flat_store_attributes.each do |attribute|
+          unless instance_variables_excluding_dirty_tracking_field.map(&:to_s).include? "@#{attribute}"
+            initialize_property(attribute, {})
+          end
+        end
+      end
+
+      def submittable_attribute?(attribute, value)
+        # FlatStores always submitted, even if not changed, as we don't track their dirtyness
+        value.is_a?(Intercom::Lib::FlatStore) || field_changed?(attribute)
+      end
+
+      module ClassMethods
+        def from_api(api_response)
+          object = self.new
+          object.from_response(api_response)
+          object
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end