Class: CoreLibrary::ResponseHandler

Inherits:
Object
  • Object
show all
Defined in:
lib/apimatic-core/response_handler.rb

Overview

Creates an instance of ResponseHandler.

Instance Method Summary collapse

Constructor Details

#initialize ⇒ ResponseHandler

Creates an instance of ResponseHandler.



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/apimatic-core/response_handler.rb', line 5

def initialize
  @deserializer = nil
  @convertor = nil
  @deserialize_into = nil
  @is_api_response = false
  @is_nullify404 = false
  @local_errors = {}
  @datetime_format = nil
  @is_xml_response = false
  @xml_attribute = nil
  @endpoint_name_for_logging = nil
  @endpoint_logger = nil
  @is_primitive_response = false
  @is_date_response = false
  @is_response_array = false
  @is_response_void = false
end

Instance Method Details

#apply_api_response(response, deserialized_value) ⇒ Object

Applies API response.

Parameters:

  • response —

    The actual HTTP response.

  • deserialized_value —

    The deserialized value.



234
235
236
237
238
239
240
241
 
# File 'lib/apimatic-core/response_handler.rb', line 234

def apply_api_response(response, deserialized_value)
  if @is_api_response
    errors = ApiHelper.map_response(deserialized_value, ['errors'])
    return ApiResponse.new(response, data: deserialized_value, errors: errors)
  end

  deserialized_value
end

#apply_convertor(deserialized_value) ⇒ Object

Applies converter to the response.

Parameters:

  • deserialized_value —

    The deserialized value.



245
246
247
248
249
 
# File 'lib/apimatic-core/response_handler.rb', line 245

def apply_convertor(deserialized_value)
  return @convertor.call(deserialized_value) unless @convertor.nil?

  deserialized_value
end

#apply_deserializer(response, should_symbolize_hash) ⇒ Object

Applies deserializer to the response.

Parameters:

  • should_symbolize_hash (Boolean) —

    Flag to symbolize the hash during response deserialization.



216
217
218
219
220
221
222
223
224
225
226
227
228
229
 
# File 'lib/apimatic-core/response_handler.rb', line 216

def apply_deserializer(response, should_symbolize_hash)
  return apply_xml_deserializer(response) if @is_xml_response
  return response.raw_body if @deserializer.nil?

  if @datetime_format
    @deserializer.call(response.raw_body, @datetime_format, @is_response_array, should_symbolize_hash)
  elsif @is_date_response
    @deserializer.call(response.raw_body, @is_response_array, should_symbolize_hash)
  elsif !@deserialize_into.nil? || @is_primitive_response
    @deserializer.call(response.raw_body, @deserialize_into, @is_response_array, should_symbolize_hash)
  else
    @deserializer.call(response.raw_body, should_symbolize_hash)
  end
end

#apply_xml_deserializer(response) ⇒ Object

Applies xml deserializer to the response.



205
206
207
208
209
210
211
212
 
# File 'lib/apimatic-core/response_handler.rb', line 205

def apply_xml_deserializer(response)
  unless @xml_attribute.get_array_item_name.nil?
    return @deserializer.call(response.raw_body, @xml_attribute.get_root_element_name,
                              @xml_attribute.get_array_item_name, @deserialize_into, @datetime_format)
  end

  @deserializer.call(response.raw_body, @xml_attribute.get_root_element_name, @deserialize_into, @datetime_format)
end

#convertor(convertor) ⇒ ResponseHandler

Sets converter for the response.

Parameters:

  • convertor (Method) —

    The method to be called while converting the deserialized response.

Returns:



34
35
36
37
 
# File 'lib/apimatic-core/response_handler.rb', line 34

def convertor(convertor)
  @convertor = convertor
  self
end

#datetime_format(datetime_format) ⇒ ResponseHandler

Sets the datetime format.

Parameters:

  • datetime_format (DateTimeFormat) —

    The date time format to deserialize against.

Returns:



74
75
76
77
 
# File 'lib/apimatic-core/response_handler.rb', line 74

def datetime_format(datetime_format)
  @datetime_format = datetime_format
  self
end

#deserialize_into(deserialize_into) ⇒ ResponseHandler

Sets the model to deserialize into.

Parameters:

  • deserialize_into (Method) —

    The method to be called while deserializing.

Returns:



42
43
44
45
 
# File 'lib/apimatic-core/response_handler.rb', line 42

def deserialize_into(deserialize_into)
  @deserialize_into = deserialize_into
  self
end

#deserializer(deserializer) ⇒ ResponseHandler

Sets deserializer for the response.

Parameters:

  • deserializer (Method) —

    The method to be called for deserializing the response.

Returns:



26
27
28
29
 
# File 'lib/apimatic-core/response_handler.rb', line 26

def deserializer(deserializer)
  @deserializer = deserializer
  self
end

#endpoint_logger(endpoint_logger) ⇒ ResponseHandler

Sets endpoint logger to be used.

Parameters:

  • endpoint_logger (EndpointLogger) —

    The logger to be used for logging API call steps.

Returns:



98
99
100
101
 
# File 'lib/apimatic-core/response_handler.rb', line 98

def endpoint_logger(endpoint_logger)
  @endpoint_logger = endpoint_logger
  self
end

#endpoint_name_for_logging(endpoint_name_for_logging) ⇒ ResponseHandler

Sets the endpoint_name_for_logging property.

Parameters:

  • endpoint_name_for_logging (String) —

    The endpoint method name to be used while logging.

Returns:



90
91
92
93
 
# File 'lib/apimatic-core/response_handler.rb', line 90

def endpoint_name_for_logging(endpoint_name_for_logging)
  @endpoint_name_for_logging = endpoint_name_for_logging
  self
end

#handle(response, global_errors, should_symbolize_hash = false) ⇒ Object

Main method to handle the response with all the set properties.

Parameters:

  • response (HttpResponse) —

    The response received.

  • global_errors (Hash) —

    The global errors object.

  • should_symbolize_hash (Boolean) (defaults to: false) —

    Flag to symbolize the hash during response deserialization.

Returns:

  • (Object) —

    The deserialized response of the API Call.



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/apimatic-core/response_handler.rb', line 166

def handle(response, global_errors, should_symbolize_hash = false)
  @endpoint_logger.info("Validating response for #{@endpoint_name_for_logging}.")

  # checking Nullify 404
  if response.status_code == 404 && @is_nullify404
    @endpoint_logger.info("Status code 404 received for #{@endpoint_name_for_logging}. Returning None.")
    return nil
  end

  # validating response if configured
  validate(response, global_errors)

  return if @is_response_void

  # applying deserializer if configured
  deserialized_value = apply_deserializer(response, should_symbolize_hash)

  # applying api_response if configured
  deserialized_value = apply_api_response(response, deserialized_value)

  # applying convertor if configured
  deserialized_value = apply_convertor(deserialized_value)

  deserialized_value
end

#is_api_response(is_api_response) ⇒ ResponseHandler

Sets the is_api_response property.

Parameters:

  • is_api_response (Boolean) —

    Flag to return the complete http response.

Returns:



115
116
117
118
 
# File 'lib/apimatic-core/response_handler.rb', line 115

def is_api_response(is_api_response)
  @is_api_response = is_api_response
  self
end

#is_date_response(is_date_response) ⇒ ResponseHandler

Sets the is_date_response property.

Parameters:

  • is_date_response (Boolean) —

    Flag if the response is a date.

Returns:



139
140
141
142
 
# File 'lib/apimatic-core/response_handler.rb', line 139

def is_date_response(is_date_response)
  @is_date_response = is_date_response
  self
end

#is_nullify404(is_nullify404) ⇒ ResponseHandler

Sets the is_nullify404 property.

Parameters:

  • is_nullify404 (Boolean) —

    Flag to return early in case of 404 error code.

Returns:



123
124
125
126
 
# File 'lib/apimatic-core/response_handler.rb', line 123

def is_nullify404(is_nullify404)
  @is_nullify404 = is_nullify404
  self
end

#is_primitive_response(is_primitive_response) ⇒ ResponseHandler

Sets the is_primitive_response property. rubocop:disable Naming/PredicateName

Parameters:

  • is_primitive_response (Boolean) —

    Flag if the response is of primitive type.

Returns:



107
108
109
110
 
# File 'lib/apimatic-core/response_handler.rb', line 107

def is_primitive_response(is_primitive_response)
  @is_primitive_response = is_primitive_response
  self
end

#is_response_array(is_response_array) ⇒ ResponseHandler

Sets the is_response_array property.

Parameters:

  • is_response_array (Boolean) —

    Flag if the response is an array.

Returns:



147
148
149
150
 
# File 'lib/apimatic-core/response_handler.rb', line 147

def is_response_array(is_response_array)
  @is_response_array = is_response_array
  self
end

#is_response_void(is_response_void) ⇒ ResponseHandler

Sets the is_response_void property.

Parameters:

  • is_response_void (Boolean) —

    Flag if the response is void.

Returns:



155
156
157
158
 
# File 'lib/apimatic-core/response_handler.rb', line 155

def is_response_void(is_response_void)
  @is_response_void = is_response_void
  self
end

#is_xml_response(is_xml_response) ⇒ ResponseHandler

Set the is_xml_response property.

Parameters:

  • is_xml_response (Boolean) —

    Flag if the response is XML.

Returns:



131
132
133
134
 
# File 'lib/apimatic-core/response_handler.rb', line 131

def is_xml_response(is_xml_response)
  @is_xml_response = is_xml_response
  self
end

#local_error(error_code, error_message, exception_type) ⇒ ResponseHandler

Registers an entry with error message in the local errors hash.

Parameters:

  • error_code (String) —

    The error code to check against.

  • error_message (String) —

    The reason for the exception.

  • exception_type (ApiException) —

    The type of the exception to raise.

Returns:



52
53
54
55
56
57
 
# File 'lib/apimatic-core/response_handler.rb', line 52

def local_error(error_code, error_message, exception_type)
  @local_errors[error_code.to_s] = ErrorCase.new
                                            .error_message(error_message)
                                            .exception_type(exception_type)
  self
end

#local_error_template(error_code, error_message_template, exception_type) ⇒ ResponseHandler

Registers an entry with error template in the local errors hash.

Parameters:

  • error_code (String) —

    The error code to check against.

  • error_message_template (String) —

    The reason template for the exception.

  • exception_type (ApiException) —

    The type of the exception to raise.

Returns:



64
65
66
67
68
69
 
# File 'lib/apimatic-core/response_handler.rb', line 64

def local_error_template(error_code, error_message_template, exception_type)
  @local_errors[error_code.to_s] = ErrorCase.new
                                            .error_message_template(error_message_template)
                                            .exception_type(exception_type)
  self
end

#validate(response, global_errors) ⇒ Object

Validates the response provided and throws an error against the configured status code.

Parameters:

  • response (HttpResponse) —

    The received response.

  • global_errors (Hash) —

    Global errors hash.

Raises:

  • (ApiException) —

    Throws the exception when the response contains errors.



196
197
198
199
200
201
202
 
# File 'lib/apimatic-core/response_handler.rb', line 196

def validate(response, global_errors)
  return unless response.status_code < 200 || response.status_code > 299

  validate_against_error_cases(response, @local_errors)

  validate_against_error_cases(response, global_errors)
end

#validate_against_error_cases(response, error_cases) ⇒ Object

Validates the response against the provided error cases hash, if matches, it raises the exception.

Parameters:

  • response (HttpResponse) —

    The received response.

  • error_cases (Hash) —

    The error cases hash.

Raises:

  • (ApiException) —

    Raises the APIException when configured error code matches.



255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/apimatic-core/response_handler.rb', line 255

def validate_against_error_cases(response, error_cases)
  actual_status_code = response.status_code.to_s

  # Handling error case when configured as explicit error code
  error_case = error_cases[actual_status_code]
  error_case&.raise_exception(response)

  # Handling error case when configured as explicit error codes range
  default_range_entry = error_cases&.filter do |error_code, _|
    error_code.match?("^#{actual_status_code[0]}XX$")
  end

  default_range_error_case = default_range_entry&.map { |_, error_case_instance| error_case_instance }

  default_range_error_case[0].raise_exception(response) unless
    default_range_error_case.nil? || default_range_error_case.empty?

  # Handling default error case if configured
  default_error_case = error_cases['default']
  default_error_case&.raise_exception(response)
end

#xml_attribute(xml_attribute) ⇒ ResponseHandler

Set the xml_attribute property.

Parameters:

  • xml_attribute (XmlAttributes) —

    The xml configuration if the response is XML.

Returns:



82
83
84
85
 
# File 'lib/apimatic-core/response_handler.rb', line 82

def xml_attribute(xml_attribute)
  @xml_attribute = xml_attribute
  self
end