supportify_client 1.0.2 → 3.0.0

data/lib/supportify_client/api_client.rb

@@ -7,36 +7,37 @@ require 'uri'
 
 module Supportify
   class ApiClient
-
-    attr_accessor :host
+    # The Configuration object holding settings to be used in the API client.
+    attr_accessor :config
 
     # Defines the headers to be used in HTTP requests of all API calls by default.
     #
     # @return [Hash]
     attr_accessor :default_headers
 
-    # Stores the HTTP response from the last API call using this API client.
-    attr_accessor :last_response
-
-    def initialize(host = nil)
-      @host = host || Configuration.base_url
-      @format = 'json'
+    def initialize(config = Configuration.default)
+      @config = config
       @user_agent = "ruby-swagger-#{VERSION}"
       @default_headers = {
-        'Content-Type' => "application/#{@format.downcase}",
+        'Content-Type' => "application/json",
         'User-Agent' => @user_agent
       }
     end
 
+    def self.default
+      @@default ||= ApiClient.new
+    end
+
+    # Call an API with given options.
+    #
+    # @return [Array<(Object, Fixnum, Hash)>] an array of 3 elements:
+    #   the data deserialized from response body (could be nil), response status code and response headers.
     def call_api(http_method, path, opts = {})
       request = build_request(http_method, path, opts)
       response = request.run
 
-      # record as last response
-      @last_response = response
-
-      if Configuration.debugging
-        Configuration.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
+      if @config.debugging
+        @config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
       end
 
       unless response.success?
@@ -47,10 +48,11 @@ module Supportify
       end
 
       if opts[:return_type]
-        deserialize(response, opts[:return_type])
+        data = deserialize(response, opts[:return_type])
       else
-        nil
+        data = nil
       end
+      return data, response.code, response.headers
     end
 
     def build_request(http_method, path, opts = {})
@@ -69,22 +71,34 @@ module Supportify
         :method => http_method,
         :headers => header_params,
         :params => query_params,
-        :ssl_verifypeer => Configuration.verify_ssl,
-        :cainfo => Configuration.ssl_ca_cert,
-        :verbose => Configuration.debugging
+        :timeout => @config.timeout,
+        :ssl_verifypeer => @config.verify_ssl,
+        :sslcert => @config.cert_file,
+        :sslkey => @config.key_file,
+        :cainfo => @config.ssl_ca_cert,
+        :verbose => @config.debugging
       }
 
       if [:post, :patch, :put, :delete].include?(http_method)
         req_body = build_request_body(header_params, form_params, opts[:body])
         req_opts.update :body => req_body
-        if Configuration.debugging
-          Configuration.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
+        if @config.debugging
+          @config.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
         end
       end
 
       Typhoeus::Request.new(url, req_opts)
     end
 
+    # Check if the given MIME is a JSON MIME.
+    # JSON MIME examples:
+    #   application/json
+    #   application/json; charset=UTF8
+    #   APPLICATION/JSON
+    def json_mime?(mime)
+       !!(mime =~ /\Aapplication\/json(;.*)?\z/i)
+    end
+
     # Deserialize the response to the given return type.
     #
     # @param [String] return_type some examples: "User", "Array[User]", "Hash[String,Integer]"
@@ -98,9 +112,7 @@ module Supportify
       # ensuring a default content type
       content_type = response.headers['Content-Type'] || 'application/json'
 
-      unless content_type.start_with?('application/json')
-        fail "Content-Type is not supported: #{content_type}"
-      end
+      fail "Content-Type is not supported: #{content_type}" unless json_mime?(content_type)
 
       begin
         data = JSON.parse("[#{body}]", :symbolize_names => true)[0]
@@ -158,38 +170,58 @@ module Supportify
     # from the "Content-Disposition" header if provided, otherwise a random filename.
     #
     # @see Configuration#temp_folder_path
-    # @return [File] the file downloaded
+    # @return [Tempfile] the file downloaded
     def download_file(response)
-      tmp_file = Tempfile.new '', Configuration.temp_folder_path
       content_disposition = response.headers['Content-Disposition']
       if content_disposition
         filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
-        path = File.join File.dirname(tmp_file), filename
+        prefix = sanitize_filename(filename)
       else
-        path = tmp_file.path
+        prefix = 'download-'
+      end
+      prefix = prefix + '-' unless prefix.end_with?('-')
+
+      tempfile = nil
+      encoding = response.body.encoding
+      Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding) do |file|
+        file.write(response.body)
+        tempfile = file
       end
-      # close and delete temp file
-      tmp_file.close!
+      @config.logger.info "Temp file written to #{tempfile.path}, please copy the file to a proper folder "\
+                          "with e.g. `FileUtils.cp(tempfile.path, '/new/file/path')` otherwise the temp file "\
+                          "will be deleted automatically with GC. It's also recommended to delete the temp file "\
+                          "explicitly with `tempfile.delete`"
+      tempfile
+    end
 
-      File.open(path, 'w') { |file| file.write(response.body) }
-      Configuration.logger.info "File written to #{path}. Please move the file to a proper "\
-                                "folder for further processing and delete the temp afterwards"
-      File.new(path)
+    # Sanitize filename by removing path.
+    # e.g. ../../sun.gif becomes sun.gif
+    #
+    # @param [String] filename the filename to be sanitized
+    # @return [String] the sanitized filename
+    def sanitize_filename(filename)
+      filename.gsub /.*[\/\\]/, ''
     end
 
     def build_request_url(path)
       # Add leading and trailing slashes to path
       path = "/#{path}".gsub(/\/+/, '/')
-      URI.encode(host + path)
+      URI.encode(@config.base_url + path)
     end
 
     def build_request_body(header_params, form_params, body)
       # http form
       if header_params['Content-Type'] == 'application/x-www-form-urlencoded' ||
           header_params['Content-Type'] == 'multipart/form-data'
-        data = form_params.dup
-        data.each do |key, value|
-          data[key] = value.to_s if value && !value.is_a?(File)
+        data = {}
+        form_params.each do |key, value|
+          case value
+          when File, Array, nil
+            # let typhoeus handle File, Array and nil parameters
+            data[key] = value
+          else
+            data[key] = value.to_s
+          end
         end
       elsif body
         data = body.is_a?(String) ? body : body.to_json
@@ -202,7 +234,7 @@ module Supportify
     # Update hearder and query params based on authentication settings.
     def update_params_for_auth!(header_params, query_params, auth_names)
       Array(auth_names).each do |auth_name|
-        auth_setting = Configuration.auth_settings[auth_name]
+        auth_setting = @config.auth_settings[auth_name]
         next unless auth_setting
         case auth_setting[:in]
         when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
@@ -221,26 +253,21 @@ module Supportify
     # @param [Array] accepts array for Accept
     # @return [String] the Accept header (e.g. application/json)
     def select_header_accept(accepts)
-      if accepts.empty?
-        return
-      elsif accepts.any?{ |s| s.casecmp('application/json') == 0 }
-        'application/json' # look for json data by default
-      else
-        accepts.join(',')
-      end
+      return nil if accepts.nil? || accepts.empty?
+      # use JSON when present, otherwise use all of the provided
+      json_accept = accepts.find { |s| json_mime?(s) }
+      return json_accept || accepts.join(',')
     end
 
     # Return Content-Type header based on an array of content types provided.
     # @param [Array] content_types array for Content-Type
     # @return [String] the Content-Type header  (e.g. application/json)
     def select_header_content_type(content_types)
-      if content_types.empty?
-        'application/json' # use application/json by default
-      elsif content_types.any?{ |s| s.casecmp('application/json')==0 }
-        'application/json' # use application/json if it's included
-      else
-        content_types[0] # otherwise, use the first one
-      end
+      # use application/json by default
+      return 'application/json' if content_types.nil? || content_types.empty?
+      # use JSON when present, otherwise use the first one
+      json_content_type = content_types.find { |s| json_mime?(s) }
+      return json_content_type || content_types.first
     end
 
     # Convert object (array, hash, object, etc) to JSON string.
@@ -267,5 +294,25 @@ module Supportify
         obj
       end
     end
+
+    # Build parameter value according to the given collection format.
+    # @param [String] collection_format one of :csv, :ssv, :tsv, :pipes and :multi
+    def build_collection_param(param, collection_format)
+      case collection_format
+      when :csv
+        param.join(',')
+      when :ssv
+        param.join(' ')
+      when :tsv
+        param.join("\t")
+      when :pipes
+        param.join('|')
+      when :multi
+        # return the array directly as typhoeus will handle it as expected
+        param
+      else
+        fail "unknown collection format: #{collection_format.inspect}"
+      end
+    end
   end
 end

data/lib/supportify_client/configuration.rb

@@ -1,14 +1,7 @@
 require 'uri'
-require 'singleton'
 
 module Supportify
   class Configuration
-
-    include Singleton
-
-    # Default api client
-    attr_accessor :api_client
-
     # Defines url scheme
     attr_accessor :scheme
 
@@ -44,6 +37,9 @@ module Supportify
     # @return [String]
     attr_accessor :password
 
+    # Defines the access token (Bearer) used with OAuth2.
+    attr_accessor :access_token
+
     # Set this to enable/disable debugging. When enabled (set to true), HTTP request/response
     # details will be logged with `logger.debug` (see the `logger` attribute).
     # Default to false.
@@ -64,6 +60,11 @@ module Supportify
     # @return [String]
     attr_accessor :temp_folder_path
 
+    # The time limit for HTTP request in seconds.
+    # Default to 0 (never times out).
+    attr_accessor :timeout
+
+    ### TLS/SSL
     # Set this to false to skip verifying SSL certificate when calling API from https server.
     # Default to true.
     #
@@ -80,36 +81,41 @@ module Supportify
     # https://github.com/typhoeus/typhoeus/blob/master/lib/typhoeus/easy_factory.rb#L145
     attr_accessor :ssl_ca_cert
 
+    # Client certificate file (for client certificate)
+    attr_accessor :cert_file
+
+    # Client private key file (for client certificate)
+    attr_accessor :key_file
+
     attr_accessor :inject_format
 
     attr_accessor :force_ending_format
 
-    class << self
-      def method_missing(method_name, *args, &block)
-        config = Configuration.instance
-        if config.respond_to?(method_name)
-          config.send(method_name, *args, &block)
-        else
-          super
-        end
-      end
-    end
-
     def initialize
       @scheme = 'https'
       @host = 'api.supportify.io'
-      @base_path = '/v2'
+      @base_path = '/v3'
       @api_key = {}
       @api_key_prefix = {}
+      @timeout = 0
       @verify_ssl = true
+      @cert_file = nil
+      @key_file = nil
       @debugging = false
       @inject_format = false
       @force_ending_format = false
       @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+
+      yield(self) if block_given?
+    end
+
+    # The default Configuration object.
+    def self.default
+      @@default ||= Configuration.new
     end
 
-    def api_client
-      @api_client ||= ApiClient.new
+    def configure
+      yield(self) if block_given?
     end
 
     def scheme=(scheme)
@@ -129,7 +135,7 @@ module Supportify
     end
 
     def base_url
-      url = "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}"
+      url = "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '')
       URI.encode(url)
     end
 
@@ -163,23 +169,23 @@ module Supportify
     def application_api_key
       @api_key['X-SUPPORTIFY-APPKEY']
     end
-    
+
     # Returns Auth Settings hash for api client.
     def auth_settings
       {
-        'api_key' =>
+        'app_key' =>
           {
             type: 'api_key',
             in: 'header',
-            key: 'X-SUPPORTIFY-APIKEY',
-            value: api_key_with_prefix('X-SUPPORTIFY-APIKEY')
+            key: 'X-SUPPORTIFY-APPKEY',
+            value: api_key_with_prefix('X-SUPPORTIFY-APPKEY')
           },
-        'app_key' =>
+        'api_key' =>
           {
             type: 'api_key',
             in: 'header',
-            key: 'X-SUPPORTIFY-APPKEY',
-            value: api_key_with_prefix('X-SUPPORTIFY-APPKEY')
+            key: 'X-SUPPORTIFY-APIKEY',
+            value: api_key_with_prefix('X-SUPPORTIFY-APIKEY')
           },
       }
     end

data/lib/supportify_client/models/category.rb

@@ -1,24 +1,30 @@
+require 'date'
+
 module Supportify
-  # 
-  class Category < BaseObject
-    attr_accessor :id, :description, :name
-    # attribute mapping from ruby-style variable name to JSON key
+  class Category
+    # Unique identifier representing a specific category within an application.
+    attr_accessor :id
+
+    # Description of the category.
+    attr_accessor :description
+
+    # Display name of the category.
+    attr_accessor :name
+
+    # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         
-        # Unique identifier representing a specific category within an application.
         :'id' => :'id',
         
-        # Description of the category.
         :'description' => :'description',
         
-        # Display name of the category.
         :'name' => :'name'
         
       }
     end
 
-    # attribute type
+    # Attribute type mapping.
     def self.swagger_types
       {
         :'id' => :'Integer',
@@ -29,7 +35,7 @@ module Supportify
     end
 
     def initialize(attributes = {})
-      return if !attributes.is_a?(Hash) || attributes.empty?
+      return unless attributes.is_a?(Hash)
 
       # convert string to symbol for hash key
       attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
@@ -49,5 +55,115 @@ module Supportify
       
     end
 
+    # Check equality by comparing each attribute.
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          id == o.id &&
+          description == o.description &&
+          name == o.name
+    end
+
+    # @see the `==` method
+    def eql?(o)
+      self == o
+    end
+
+    # Calculate hash code according to all attributes.
+    def hash
+      [id, description, name].hash
+    end
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        _model = Supportify.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
   end
 end