-
1
require 'date'
-
1
require 'json'
-
1
require 'logger'
-
1
require 'tempfile'
-
1
require 'time'
-
1
require 'faraday'
-
1
require 'minato/trace'
-
1
require 'ostruct'
-
-
1
module MinatoRubyApiClient
-
1
class ApiClient
-
# The Configuration object holding settings to be used in the API client.
-
1
attr_accessor :config
-
-
# Defines the headers to be used in HTTP requests of all API calls by default.
-
#
-
# @return [Hash]
-
1
attr_accessor :default_headers
-
-
# Initializes the ApiClient
-
# @option config [Configuration] Configuration for initializing the object, default to Configuration.default
-
1
def initialize(config = Configuration.default)
-
11
@config = config
-
11
@user_agent = config.user_agent
-
@default_headers = {
-
11
'Content-Type' => 'application/json',
-
'User-Agent' => @user_agent
-
}
-
-
11
if defined?(Rails) && Rails.env.production? && Minato::Trace.enabled?
-
1
@config.use(Minato::Trace::Middleware::DistributedTraceContext)
-
end
-
end
-
-
1
def self.default
-
25
@@default ||= ApiClient.new
-
end
-
-
# Call an API with given options.
-
#
-
# @return [Array<(Object, Integer, Hash)>] an array of 3 elements:
-
# the data deserialized from response body (could be nil), response status code and response headers.
-
1
def call_api(http_method, path, opts = {})
-
ssl_options = {
-
4
:ca_file => @config.ssl_ca_file,
-
:verify => @config.ssl_verify,
-
:verify_mode => @config.ssl_verify_mode,
-
:client_cert => @config.ssl_client_cert,
-
:client_key => @config.ssl_client_key
-
}
-
-
4
connection = Faraday.new(:url => config.base_url, :ssl => ssl_options) do |conn|
-
4
@config.configure_middleware(conn)
-
4
if opts[:header_params] && opts[:header_params]["Content-Type"] == "multipart/form-data"
-
conn.request :multipart
-
conn.request :url_encoded
-
end
-
4
conn.adapter(Faraday.default_adapter)
-
end
-
-
4
request = nil
-
-
begin
-
4
response = connection.public_send(http_method.to_sym.downcase) do |req|
-
4
request = req
-
4
build_request(http_method, path, req, opts)
-
end
-
-
3
@config.logger.info({ 'message' => "Receive response from #{response.env.url}",
-
'http_response' => response.to_hash })
-
-
3
unless response.success?
-
1
error = self.class.module_parent::ApiError.new(:status_code => response.status,
-
:res => response, :req => request)
-
1
error.caused_by = response.reason_phrase
-
-
1
fail error
-
end
-
rescue Faraday::TimeoutError => e
-
1
error = self.class.module_parent::ApiError.new(req: request, res: response, status_code: 408)
-
1
error.caused_by = e
-
1
fail error
-
end
-
-
2
if opts[:return_type]
-
1
data = deserialize(response, opts[:return_type])
-
else
-
1
data = nil
-
end
-
2
return data, response.status, response.headers
-
end
-
-
# Builds the HTTP request
-
#
-
# @param [String] http_method HTTP method/verb (e.g. POST)
-
# @param [String] path URL path (e.g. /account/new)
-
# @option opts [Hash] :header_params Header parameters
-
# @option opts [Hash] :query_params Query parameters
-
# @option opts [Hash] :form_params Query parameters
-
# @option opts [Object] :body HTTP body (JSON/XML)
-
# @return [Typhoeus::Request] A Typhoeus Request
-
1
def build_request(http_method, path, request, opts = {})
-
4
url = build_request_url(path)
-
4
http_method = http_method.to_sym.downcase
-
-
4
header_params = @default_headers.merge(opts[:header_params] || {})
-
4
query_params = opts[:query_params] || {}
-
4
form_params = opts[:form_params] || {}
-
-
4
update_params_for_auth! header_params, query_params, opts[:auth_names]
-
-
req_opts = {
-
4
:params_encoding => @config.params_encoding,
-
:timeout => @config.timeout,
-
:verbose => @config.debugging
-
}
-
-
4
if [:post, :patch, :put, :delete].include?(http_method)
-
3
req_body = build_request_body(header_params, form_params, opts[:body])
-
end
-
4
request.headers = header_params
-
4
request.body = req_body
-
4
request.options = OpenStruct.new(req_opts)
-
4
request.url url
-
4
request.params = query_params
-
4
download_file(request) if opts[:return_type] == 'File'
-
-
4
@config.logger.info({ 'message' => "Starting request to #{url}",
-
'http_request' => request.to_h })
-
-
4
request
-
end
-
-
# Builds the HTTP request body
-
#
-
# @param [Hash] header_params Header parameters
-
# @param [Hash] form_params Query parameters
-
# @param [Object] body HTTP body (JSON/XML)
-
# @return [String] HTTP body data in the form of string
-
1
def build_request_body(header_params, form_params, body)
-
# http form
-
8
if header_params['Content-Type'] == 'application/x-www-form-urlencoded'
-
1
data = URI.encode_www_form(form_params)
-
7
elsif header_params['Content-Type'] == 'multipart/form-data'
-
1
data = {}
-
1
form_params.each do |key, value|
-
2
case value
-
when ActionDispatch::Http::UploadedFile
-
# TODO hardcode to application/octet-stream, need better way to detect content type
-
data[key] = Faraday::UploadIO.new(value.path, value.content_type, value.original_filename)
-
when ::File, ::Tempfile
-
# TODO hardcode to application/octet-stream, need better way to detect content type
-
data[key] = Faraday::UploadIO.new(value.path, 'application/octet-stream', value.path)
-
when ::Array, nil
-
# let Faraday handle Array and nil parameters
-
data[key] = value
-
else
-
2
data[key] = value.to_s
-
end
-
end
-
6
elsif body
-
5
data = body.is_a?(String) ? body : body.to_json
-
else
-
1
data = nil
-
end
-
8
data
-
end
-
-
1
def download_file(request)
-
@stream = []
-
-
# handle streaming Responses
-
request.options.on_data = Proc.new do |chunk, overall_received_bytes|
-
@stream << chunk
-
end
-
end
-
-
# Check if the given MIME is a JSON MIME.
-
# JSON MIME examples:
-
# application/json
-
# application/json; charset=UTF8
-
# APPLICATION/JSON
-
# */*
-
# @param [String] mime MIME
-
# @return [Boolean] True if the MIME is application/json
-
1
def json_mime?(mime)
-
3
(mime == '*/*') || !(mime =~ /Application\/.*json(?!p)(;.*)?/i).nil?
-
end
-
-
# Deserialize the response to the given return type.
-
#
-
# @param [Response] response HTTP response
-
# @param [String] return_type some examples: "User", "Array<User>", "Hash<String, Integer>"
-
1
def deserialize(response, return_type)
-
1
body = response.body
-
-
# handle file downloading - return the File instance processed in request callbacks
-
# note that response body is empty when the file is written in chunks in request on_body callback
-
1
if return_type == 'File'
-
content_disposition = response.headers['Content-Disposition']
-
if content_disposition && content_disposition =~ /filename=/i
-
filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
-
prefix = sanitize_filename(filename)
-
else
-
prefix = 'download-'
-
end
-
prefix = prefix + '-' unless prefix.end_with?('-')
-
encoding = body.encoding
-
@tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding)
-
@tempfile.write(@stream.join.force_encoding(encoding))
-
@tempfile.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`"
-
return @tempfile
-
end
-
-
1
return nil if body.nil? || body.empty?
-
-
# return response body directly for String return type
-
1
return body if return_type == 'String'
-
-
# ensuring a default content type
-
1
content_type = response.headers['Content-Type'] || 'application/json'
-
-
1
fail "Content-Type is not supported: #{content_type}" unless json_mime?(content_type)
-
-
begin
-
1
data = JSON.parse("[#{body}]", :symbolize_names => true)[0]
-
rescue JSON::ParserError => e
-
if %w(String Date Time).include?(return_type)
-
data = body
-
else
-
raise e
-
end
-
end
-
-
1
convert_to_type data, return_type
-
end
-
-
# Convert data to the given return type.
-
# @param [Object] data Data to be converted
-
# @param [String] return_type Return type
-
# @return [Mixed] Data in a particular type
-
1
def convert_to_type(data, return_type)
-
17
return nil if data.nil?
-
16
case return_type
-
when 'String'
-
4
data.to_s
-
when 'Integer'
-
3
data.to_i
-
when 'Float'
-
1
data.to_f
-
when 'Boolean'
-
1
data == true
-
when 'Time'
-
# parse date time (expecting ISO 8601 format)
-
1
Time.parse data
-
when 'Date'
-
# parse date time (expecting ISO 8601 format)
-
1
Date.parse data
-
when 'Object'
-
# generic object (usually a Hash), return directly
-
2
data
-
when /\AArray<(.+)>\z/
-
# e.g. Array<Pet>
-
1
sub_type = $1
-
4
data.map { |item| convert_to_type(item, sub_type) }
-
when /\AHash\<String, (.+)\>\z/
-
# e.g. Hash<String, Integer>
-
1
sub_type = $1
-
1
{}.tap do |hash|
-
3
data.each { |k, v| hash[k] = convert_to_type(v, sub_type) }
-
end
-
else
-
# models (e.g. Pet) or oneOf
-
1
klass = self.class.module_parent.const_get(return_type)
-
1
klass.respond_to?(:openapi_one_of) ? klass.build(data) : klass.build_from_hash(data)
-
end
-
end
-
-
# 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
-
1
def sanitize_filename(filename)
-
filename.gsub(/.*[\/\\]/, '')
-
end
-
-
1
def build_request_url(path)
-
# Add leading and trailing slashes to path
-
4
path = "/#{path}".gsub(/\/+/, '/')
-
4
@config.base_url + path
-
end
-
-
# Update header and query params based on authentication settings.
-
#
-
# @param [Hash] header_params Header parameters
-
# @param [Hash] query_params Query parameters
-
# @param [String] auth_names Authentication scheme name
-
1
def update_params_for_auth!(header_params, query_params, auth_names)
-
8
Array(auth_names).each do |auth_name|
-
8
auth_setting = @config.auth_settings[auth_name]
-
8
next unless auth_setting
-
4
case auth_setting[:in]
-
4
when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
-
when 'query' then query_params[auth_setting[:key]] = auth_setting[:value]
-
else fail ArgumentError, 'Authentication token must be in `query` or `header`'
-
end
-
end
-
end
-
-
# Sets user agent in HTTP header
-
#
-
# @param [String] user_agent User agent (e.g. openapi-generator/ruby/1.0.0)
-
1
def user_agent=(user_agent)
-
@user_agent = user_agent
-
@default_headers['User-Agent'] = @user_agent
-
end
-
-
# Return Accept header based on an array of accepts provided.
-
# @param [Array] accepts array for Accept
-
# @return [String] the Accept header (e.g. application/json)
-
1
def select_header_accept(accepts)
-
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) }
-
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)
-
1
def select_header_content_type(content_types)
-
# return nil by default
-
return 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) }
-
json_content_type || content_types.first
-
end
-
-
# Convert object (array, hash, object, etc) to JSON string.
-
# @param [Object] model object to be converted into JSON string
-
# @return [String] JSON string representation of the object
-
1
def object_to_http_body(model)
-
return model if model.nil? || model.is_a?(String)
-
local_body = nil
-
if model.is_a?(Array)
-
local_body = model.map { |m| object_to_hash(m) }
-
else
-
local_body = object_to_hash(model)
-
end
-
local_body.to_json
-
end
-
-
# Convert object(non-array) to hash.
-
# @param [Object] obj object to be converted into JSON string
-
# @return [String] JSON string representation of the object
-
1
def object_to_hash(obj)
-
if obj.respond_to?(:to_hash)
-
obj.to_hash
-
else
-
obj
-
end
-
end
-
-
# Build parameter value according to the given collection format.
-
# @param [String] collection_format one of :csv, :ssv, :tsv, :pipes and :multi
-
1
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
