discourse_zendesk_api 1.0.0

data/lib/zendesk_api/middleware/request/etag_cache.rb

@@ -0,0 +1,52 @@
+require "faraday/middleware"
+
+module ZendeskAPI
+  module Middleware
+    module Request
+      # Request middleware that caches responses based on etags
+      # can be removed once this is merged: https://github.com/pengwynn/faraday_middleware/pull/42
+      # @private
+      class EtagCache < Faraday::Middleware
+        def initialize(app, options = {})
+          @app = app
+          @cache = options[:cache] ||
+            raise("need :cache option e.g. ActiveSupport::Cache::MemoryStore.new")
+          @cache_key_prefix = options.fetch(:cache_key_prefix, :faraday_etags)
+        end
+
+        def cache_key(env)
+          [@cache_key_prefix, env[:url].to_s]
+        end
+
+        def call(environment)
+          return @app.call(environment) unless [:get, :head].include?(environment[:method])
+
+          # send known etag
+          cached = @cache.read(cache_key(environment))
+
+          if cached
+            environment[:request_headers]["If-None-Match"] ||= cached[:response_headers]["Etag"]
+          end
+
+          @app.call(environment).on_complete do |env|
+            if cached && env[:status] == 304 # not modified
+              # Handle differences in serialized env keys in Faraday < 1.0 and 1.0
+              # See https://github.com/lostisland/faraday/pull/847
+              env[:body] = cached[:body]
+              env[:response_body] = cached[:response_body]
+
+              env[:response_headers].merge!(
+                :etag => cached[:response_headers][:etag],
+                :content_type => cached[:response_headers][:content_type],
+                :content_length => cached[:response_headers][:content_length],
+                :content_encoding => cached[:response_headers][:content_encoding]
+              )
+            elsif env[:status] == 200 && env[:response_headers]["Etag"] # modified and cacheable
+              @cache.write(cache_key(env), env.to_hash)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/request/raise_rate_limited.rb

@@ -0,0 +1,31 @@
+require 'faraday/middleware'
+require 'zendesk_api/error'
+
+module ZendeskAPI
+  module Middleware
+    # @private
+    module Request
+      # Faraday middleware to handle HTTP Status 429 (rate limiting) / 503 (maintenance)
+      # @private
+      class RaiseRateLimited < Faraday::Middleware
+        ERROR_CODES = [429, 503].freeze
+
+        def initialize(app, options = {})
+          super(app)
+          @logger = options[:logger]
+        end
+
+        def call(env)
+          response = @app.call(env)
+
+          if ERROR_CODES.include?(response.env[:status])
+            @logger&.warn 'You have been rate limited. Raising error...'
+            raise Error::RateLimited, env
+          else
+            response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/request/retry.rb

@@ -0,0 +1,59 @@
+require "faraday/middleware"
+module ZendeskAPI
+  module Middleware
+    # @private
+    module Request
+      # Faraday middleware to handle HTTP Status 429 (rate limiting) / 503 (maintenance)
+      # @private
+      class Retry < Faraday::Middleware
+        DEFAULT_RETRY_AFTER = 10
+        DEFAULT_ERROR_CODES = [429, 503]
+
+        def initialize(app, options = {})
+          super(app)
+          @logger = options[:logger]
+          @error_codes = options.key?(:retry_codes) && options[:retry_codes] ? options[:retry_codes] : DEFAULT_ERROR_CODES
+          @retry_on_exception = options.key?(:retry_on_exception) && options[:retry_on_exception] ? options[:retry_on_exception] : false
+        end
+
+        def call(env)
+          original_env = env.dup
+          exception_happened = false
+          if @retry_on_exception
+            begin
+              response = @app.call(env)
+            rescue StandardError => e
+              exception_happened = true
+            end
+          else
+            response = @app.call(env)
+          end
+
+          if exception_happened || @error_codes.include?(response.env[:status])
+
+            if exception_happened
+              seconds_left = DEFAULT_RETRY_AFTER.to_i
+              @logger.warn "An exception happened, waiting #{seconds_left} seconds... #{e}" if @logger
+            else
+              seconds_left = (response.env[:response_headers][:retry_after] || DEFAULT_RETRY_AFTER).to_i
+            end
+
+            @logger.warn "You have been rate limited. Retrying in #{seconds_left} seconds..." if @logger
+
+            seconds_left.times do |i|
+              sleep 1
+              time_left = seconds_left - i
+              @logger.warn "#{time_left}..." if time_left > 0 && time_left % 5 == 0 && @logger
+            end
+
+            @logger.warn "" if @logger
+
+            @app.call(original_env)
+          else
+            response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/request/upload.rb

@@ -0,0 +1,86 @@
+require "faraday/middleware"
+require "mini_mime"
+require 'tempfile'
+
+module ZendeskAPI
+  module Middleware
+    module Request
+      # @private
+      class Upload < Faraday::Middleware
+        def call(env)
+          if env[:body]
+            set_file(env[:body], :file, true)
+            traverse_hash(env[:body])
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        # Sets the proper file parameters :uploaded_data and :filename
+        # If top_level, then it removes key and and sets the parameters directly on hash,
+        # otherwise it adds the parameters to hash[key]
+        def set_file(hash, key, top_level)
+          return unless hash.key?(key)
+
+          file = if hash[key].is_a?(Hash) && hash[key].key?(:file)
+            hash[key].delete(:file)
+          else
+            hash.delete(key)
+          end
+
+          case file
+          when File, Tempfile
+            path = file.path
+          when String
+            path = file
+          else
+            if defined?(ActionDispatch) && file.is_a?(ActionDispatch::Http::UploadedFile)
+              path = file.tempfile.path
+              mime_type = file.content_type
+            else
+              warn "WARNING: Passed invalid filename #{file} of type #{file.class} to upload"
+            end
+          end
+
+          if path
+            if !top_level
+              hash[key] ||= {}
+              hash = hash[key]
+            end
+
+            unless defined?(mime_type) && !mime_type.nil?
+              mime_type = MiniMime.lookup_by_filename(path)
+              mime_type = mime_type ? mime_type.content_type : "application/octet-stream"
+            end
+
+            hash[:filename] ||= if file.respond_to?(:original_filename)
+              file.original_filename
+            else
+              File.basename(path)
+            end
+
+            hash[:uploaded_data] = Faraday::UploadIO.new(path, mime_type, hash[:filename])
+          end
+        end
+
+        # Calls #set_file on File instances or Hashes
+        # of the format { :file => File (, :filename => ...) }
+        def traverse_hash(hash)
+          hash.keys.each do |key|
+            if hash[key].is_a?(File)
+              set_file(hash, key, false)
+            elsif hash[key].is_a?(Hash)
+              if hash[key].key?(:file)
+                set_file(hash, key, false)
+              else
+                traverse_hash(hash[key])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/request/url_based_access_token.rb

@@ -0,0 +1,26 @@
+module ZendeskAPI
+  # @private
+  module Middleware
+    # @private
+    module Request
+      class UrlBasedAccessToken < Faraday::Middleware
+        def initialize(app, token)
+          super(app)
+          @token = token
+        end
+
+        def call(env)
+          if env[:url].query
+            env[:url].query += '&'
+          else
+            env[:url].query = ''
+          end
+
+          env[:url].query += "access_token=#{@token}"
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/callback.rb

@@ -0,0 +1,21 @@
+require "faraday/response"
+
+module ZendeskAPI
+  module Middleware
+    module Response
+      # @private
+      class Callback < Faraday::Response::Middleware
+        def initialize(app, client)
+          super(app)
+          @client = client
+        end
+
+        def call(env)
+          @app.call(env).on_complete do |env|
+            @client.callbacks.each { |c| c.call(env) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/deflate.rb

@@ -0,0 +1,17 @@
+module ZendeskAPI
+  # @private
+  module Middleware
+    # @private
+    module Response
+      # Faraday middleware to handle content-encoding = inflate
+      # @private
+      class Deflate < Faraday::Response::Middleware
+        def on_complete(env)
+          if !env.body.strip.empty? && env[:response_headers]['content-encoding'] == "deflate"
+            env.body = Zlib::Inflate.inflate(env.body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/gzip.rb

@@ -0,0 +1,19 @@
+require 'zlib'
+require 'stringio'
+
+module ZendeskAPI
+  # @private
+  module Middleware
+    # @private
+    module Response
+      # Faraday middleware to handle content-encoding = gzip
+      class Gzip < Faraday::Response::Middleware
+        def on_complete(env)
+          if !env[:body].strip.empty? && env[:response_headers]['content-encoding'] == "gzip"
+            env[:body] = Zlib::GzipReader.new(StringIO.new(env[:body])).read
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/logger.rb

@@ -0,0 +1,44 @@
+module ZendeskAPI
+  module Middleware
+    module Response
+      # Faraday middleware to handle logging
+      # @private
+      class Logger < Faraday::Middleware
+        LOG_LENGTH = 1000
+
+        def initialize(app, logger = nil)
+          super(app)
+
+          @logger = logger || begin
+            require 'logger'
+            ::Logger.new(STDOUT)
+          end
+        end
+
+        def call(env)
+          @logger.info "#{env[:method]} #{env[:url].to_s}"
+          @logger.debug dump_debug(env, :request_headers)
+
+          @app.call(env).on_complete do |env|
+            info = "Status #{env[:status]}"
+            info.concat(" #{env[:body].to_s[0, LOG_LENGTH]}") if (400..499).cover?(env[:status].to_i)
+
+            @logger.info info
+            @logger.debug dump_debug(env, :response_headers)
+          end
+        end
+
+        private
+
+        def dump_debug(env, headers_key)
+          info = env[headers_key].map { |k, v| "  #{k}: #{v.inspect}" }.join("\n")
+          unless env[:body].nil?
+            info.concat("\n")
+            info.concat(env[:body].inspect)
+          end
+          info
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/parse_iso_dates.rb

@@ -0,0 +1,30 @@
+require 'time'
+require "faraday/response"
+
+module ZendeskAPI
+  module Middleware
+    module Response
+      # Parse ISO dates from response body
+      # @private
+      class ParseIsoDates < Faraday::Response::Middleware
+        def call(env)
+          @app.call(env).on_complete do |env|
+            parse_dates!(env[:body])
+          end
+        end
+
+        private
+
+        def parse_dates!(value)
+          case value
+          when Hash then value.each { |key, element| value[key] = parse_dates!(element) }
+          when Array then value.each_with_index { |element, index| value[index] = parse_dates!(element) }
+          when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\Z/m then Time.parse(value)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/parse_json.rb

@@ -0,0 +1,23 @@
+module ZendeskAPI
+  # @private
+  module Middleware
+    # @private
+    module Response
+      class ParseJson < Faraday::Response::Middleware
+        CONTENT_TYPE = 'Content-Type'.freeze
+        dependency 'json'
+
+        def on_complete(env)
+          type = env[:response_headers][CONTENT_TYPE].to_s
+          type = type.split(';', 2).first if type.index(';')
+
+          return unless type == 'application/json'
+
+          unless env[:body].strip.empty?
+            env[:body] = JSON.parse(env[:body])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/raise_error.rb

@@ -0,0 +1,26 @@
+require 'zendesk_api/error'
+
+module ZendeskAPI
+  module Middleware
+    module Response
+      class RaiseError < Faraday::Response::RaiseError
+        def call(env)
+          super
+        rescue Faraday::TimeoutError, Faraday::ConnectionFailed => e
+          raise Error::NetworkError.new(e, env)
+        end
+
+        def on_complete(env)
+          case env[:status]
+          when 404
+            raise Error::RecordNotFound.new(env)
+          when 422, 413
+            raise Error::RecordInvalid.new(env)
+          when 100..199, 400..599, 300..303, 305..399
+            raise Error::NetworkError.new(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/sanitize_response.rb

@@ -0,0 +1,11 @@
+module ZendeskAPI
+  module Middleware
+    module Response
+      class SanitizeResponse < Faraday::Response::Middleware
+        def on_complete(env)
+          env[:body].scrub!('')
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/resource.rb

@@ -0,0 +1,208 @@
+require 'zendesk_api/helpers'
+require 'zendesk_api/trackie'
+require 'zendesk_api/actions'
+require 'zendesk_api/association'
+require 'zendesk_api/associations'
+require 'zendesk_api/verbs'
+
+module ZendeskAPI
+  # Represents a resource that only holds data.
+  class Data
+    include Associations
+
+    class << self
+      def inherited(klass)
+        subclasses.push(klass)
+      end
+
+      def subclasses
+        @subclasses ||= []
+      end
+
+      # The singular resource name taken from the class name (e.g. ZendeskAPI::Ticket -> ticket)
+      def singular_resource_name
+        @singular_resource_name ||= ZendeskAPI::Helpers.snakecase_string(to_s.split("::").last)
+      end
+
+      # The resource name taken from the class name (e.g. ZendeskAPI::Ticket -> tickets)
+      def resource_name
+        @resource_name ||= Inflection.plural(singular_resource_name)
+      end
+
+      def resource_path
+        [@namespace, resource_name].compact.join("/")
+      end
+
+      alias :model_key :resource_name
+
+      def namespace(namespace)
+        @namespace = namespace
+      end
+    end
+
+    # @return [Hash] The resource's attributes
+    attr_reader :attributes
+    # @return [ZendeskAPI::Association] The association
+    attr_accessor :association
+    # @return [Array] The last received errors
+    attr_accessor :errors
+    # Place to dump the last response
+    attr_accessor :response
+
+    # Create a new resource instance.
+    # @param [Client] client The client to use
+    # @param [Hash] attributes The optional attributes that describe the resource
+    def initialize(client, attributes = {})
+      raise "Expected a Hash for attributes, got #{attributes.inspect}" unless attributes.is_a?(Hash)
+      @association = attributes.delete(:association) || Association.new(:class => self.class)
+      @global_params = attributes.delete(:global) || {}
+      @client = client
+      @attributes = ZendeskAPI::Trackie.new(attributes)
+
+      if self.class.associations.none? { |a| a[:name] == self.class.singular_resource_name }
+        ZendeskAPI::Client.check_deprecated_namespace_usage @attributes, self.class.singular_resource_name
+      end
+
+      @attributes.clear_changes unless new_record?
+    end
+
+    def self.new_from_response(client, response, includes = nil)
+      new(client).tap do |resource|
+        resource.handle_response(response)
+        resource.set_includes(resource, includes, response.body) if includes
+        resource.attributes.clear_changes
+      end
+    end
+
+    # Passes the method onto the attributes hash.
+    # If the attributes are nested (e.g. { :tickets => { :id => 1 } }), passes the method onto the nested hash.
+    def method_missing(*args, &block)
+      raise NoMethodError, ":save is not defined" if args.first.to_sym == :save
+      @attributes.send(*args, &block)
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @attributes.respond_to?(method) || super
+    end
+
+    # Returns the resource id of the object or nil
+    def id
+      key?(:id) ? method_missing(:id) : nil
+    end
+
+    # Has this been object been created server-side? Does this by checking for an id.
+    def new_record?
+      id.nil?
+    end
+
+    # @private
+    def loaded_associations
+      self.class.associations.select do |association|
+        loaded = @attributes.method_missing(association[:name])
+        loaded && !(loaded.respond_to?(:empty?) && loaded.empty?)
+      end
+    end
+
+    # Returns the path to the resource
+    def path(options = {})
+      @association.generate_path(self, options)
+    end
+
+    # Passes #to_json to the underlying attributes hash
+    def to_json(*args)
+      method_missing(:to_json, *args)
+    end
+
+    # @private
+    def to_s
+      "#{self.class.singular_resource_name}: #{attributes.inspect}"
+    end
+    alias :inspect :to_s
+
+    # Compares resources by class and id. If id is nil, then by object_id
+    def ==(other)
+      return true if other.object_id == object_id
+
+      if other && !(other.is_a?(Data) || other.is_a?(Integer))
+        warn "Trying to compare #{other.class} to a Resource from #{caller.first}"
+      end
+
+      if other.is_a?(Data)
+        other.id && other.id == id
+      elsif other.is_a?(Integer)
+        id == other
+      else
+        false
+      end
+    end
+    alias :eql :==
+
+    # @private
+    def inspect
+      "#<#{self.class.name} #{@attributes.to_hash.inspect}>"
+    end
+
+    alias :to_param :attributes
+
+    private
+
+    def attributes_for_save
+      { self.class.singular_resource_name.to_sym => attributes.changes }
+    end
+  end
+
+  # Indexable resource
+  class DataResource < Data
+    attr_accessor :error, :error_message
+    extend Verbs
+  end
+
+  # Represents a resource that can only GET
+  class ReadResource < DataResource
+    include Read
+  end
+
+  # Represents a resource that can only POST
+  class CreateResource < DataResource
+    include Create
+  end
+
+  # Represents a resource that can only PUT
+  class UpdateResource < DataResource
+    include Update
+  end
+
+  # Represents a resource that can only DELETE
+  class DeleteResource < DataResource
+    include Destroy
+  end
+
+  # Represents a resource that can CRUD (create, read, update, delete).
+  class Resource < DataResource
+    include Read
+    include Create
+
+    include Update
+    include Destroy
+  end
+
+  class SingularResource < Resource
+    def attributes_for_save
+      { self.class.resource_name.to_sym => attributes.changes }
+    end
+  end
+
+  # Namespace parent class for Data/Resource classes
+  module DataNamespace
+    class << self
+      def included(base)
+        @descendants ||= []
+        @descendants << base
+      end
+
+      def descendants
+        @descendants || []
+      end
+    end
+  end
+end