Module: FastpixClient::Utils

Extended by:
T::Sig
Includes:
Kernel
Defined in:
lib/fastpix_client/utils/url.rb,
lib/fastpix_client/utils/forms.rb,
lib/fastpix_client/utils/utils.rb,
lib/fastpix_client/utils/headers.rb,
lib/fastpix_client/utils/retries.rb,
lib/fastpix_client/utils/security.rb,
lib/fastpix_client/utils/query_params.rb,
lib/fastpix_client/utils/request_bodies.rb

Defined Under Namespace

Classes: BackoffStrategy, RetryConfig

Constant Summary collapse

SECURITY_NOT_SUPPORTED = 
'not supported'
BEARER_PREFIX = 
'bearer '
SERIALIZATION_METHOD_TO_CONTENT_TYPE = 
{
  'json': 'application/json',
  'form': 'application/x-www-form-urlencoded',
  'multipart': 'multipart/form-data',
  'raw': 'application/octet-stream',
  'string': 'text/plain'
}.freeze

Class Method Summary collapse

Class Method Details

._add_form_payload_value(payload, field_name, value) ⇒ Object

Stores a form value, converting to an array when the field name repeats.



150
151
152
153
154
155
156
157
 
# File 'lib/fastpix_client/utils/utils.rb', line 150

def self._add_form_payload_value(payload, field_name, value)
  if payload.key?(field_name)
    payload[field_name] = [payload[field_name]] unless payload[field_name].is_a?(Array)
    payload[field_name] << value
  else
    payload[field_name] = value
  end
end

._append_multipart_field(form, field, field_metadata, val) ⇒ Object

Appends a single request field to the multipart form (mutates ‘form`).



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/fastpix_client/utils/forms.rb', line 124

def self._append_multipart_field(form, field, field_metadata, val)
  if field_metadata[:file] == true
    field_name = field_metadata[:field_name]
    # Handle arrays of files and single files alike
    if val.is_a? Array
      val.each { |file_obj| form.append([field_name, _extract_multipart_file(file_obj)]) }
    else
      form.append([field_name, _extract_multipart_file(val)])
    end
  elsif field_metadata[:json] == true
    form.append(
      [field_metadata.fetch(:field_name, field.name), [nil, ::Crystalline.to_json(val), 'application/json']]
    )
  else
    field_name = field_metadata.fetch(:field_name, field.name)
    if val.is_a? Array
      val.each do |value|
        next if value.nil?

        form.append([field_name, [nil, val_to_string(value)]])
      end
    else
      form.append([field_name, [nil, val_to_string(val)]])
    end
  end
end

._apply_api_key_scheme(req, sub_type, header_name, value) ⇒ Object 



107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/fastpix_client/utils/security.rb', line 107

def self._apply_api_key_scheme(req, sub_type, header_name, value)
  case sub_type
  when 'header'
    req.headers[header_name] = value
  when 'query'
    req.params[header_name] = value
  when 'cookie'
    req.headers['Cookie'][header_name] = value
  else
    raise ArgumentError, SECURITY_NOT_SUPPORTED
  end
end

._bearerize(value) ⇒ Object 



101
102
103
 
# File 'lib/fastpix_client/utils/security.rb', line 101

def self._bearerize(value)
  value.downcase.start_with?(BEARER_PREFIX) ? value : "Bearer #{value}"
end

._deep_object_from_hash(params, metadata, field_name, obj) ⇒ Object

Adds deepObject query params from a Hash (mutates ‘params`).



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/fastpix_client/utils/query_params.rb', line 107

def self._deep_object_from_hash(params, metadata, field_name, obj)
  obj.each do |key, value|
    next if value.nil?

    param_key = "#{metadata.fetch(:field_name, field_name)}[#{key}]"
    if value.is_a? Array
      value.each do |val|
        next if val.nil?

        params[param_key] = [] unless params.include? param_key

        T.must(params[param_key]).append(val_to_string(val))
      end
    else
      params[param_key] = [val_to_string(value)]
    end
  end
end

._deep_object_from_object(params, metadata, field_name, obj) ⇒ Object

Adds deepObject query params from a MetadataFields object (mutates ‘params`).



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/fastpix_client/utils/query_params.rb', line 83

def self._deep_object_from_object(params, metadata, field_name, obj)
  T.unsafe(obj).fields.each do |obj_field|
    obj_param_metadata = obj_field.metadata[:query_param]
    next if obj_param_metadata.nil?

    val = obj.send(obj_field.name)
    next if val.nil?

    key = "#{metadata.fetch(:field_name, field_name)}[#{obj_param_metadata.fetch(:field_name, obj_field.name)}]"
    if val.is_a? Array
      val.each do |v|
        next if v.nil?

        params[key] = [] unless params.include? key

        T.must(params[key]) << val_to_string(v)
      end
    else
      params[key] = [val_to_string(val)]
    end
  end
end

._extract_multipart_file(file_obj) ⇒ Object

Extracts [file_name, content] from a multipart file object, raising if invalid.

Raises:

  • (ArgumentError) 


104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/fastpix_client/utils/forms.rb', line 104

def self._extract_multipart_file(file_obj)
  file_name = T.let('', String)
  content = nil

  T.must(file_obj).fields.each do |file_field|
    file_metadata = file_field.metadata[:multipart_form]
    next if file_metadata.nil?

    if file_metadata[:content] == true
      content = T.let(file_obj.send(file_field.name), String)
    else
      file_name = T.let(file_obj.send(file_field.name), String)
    end
  end
  raise ArgumentError, 'invalid multipart/form-data file' if T.unsafe(file_name) == '' || T.unsafe(content).nil?

  [file_name, content]
end

._get_deep_object_query_params(metadata, field_name, obj) ⇒ Object 



69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/fastpix_client/utils/query_params.rb', line 69

def self._get_deep_object_query_params(metadata, field_name, obj)
  params = T.let({}, T::Hash[T.any(String, Symbol), T::Array[String]])

  return params if obj.nil?

  if obj.respond_to? :fields
    _deep_object_from_object(params, metadata, field_name, obj)
  elsif obj.is_a? Hash
    _deep_object_from_hash(params, metadata, field_name, obj)
  end
  params
end

._get_delimited_query_params(metadata, field_name, obj, delimiter) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/fastpix_client/utils/query_params.rb', line 131

def self._get_delimited_query_params(metadata, field_name, obj, delimiter)
  get_query_param_field_name = lambda do |obj_field|
    obj_param_metadata = obj_field.metadata[:query_param]

    return {} if obj_param_metadata.nil?

    return obj_param_metadata.fetch(:field_name, obj_field.name)
  end

  _populate_form(field_name, T.cast(metadata.fetch(:explode, true), T::Boolean), obj, delimiter, &get_query_param_field_name)
end

._get_serialized_params(metadata, field_name, obj) ⇒ Object 



33
34
35
36
37
38
39
40
 
# File 'lib/fastpix_client/utils/utils.rb', line 33

def self._get_serialized_params(metadata, field_name, obj)
  params = {}

  serialization = metadata.fetch(:serialization, '')
  params[metadata.fetch(:field_name, field_name)] = [obj.to_json] if serialization == 'json'

  params
end

._parse_basic_auth_scheme(req, scheme) ⇒ Object 



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/fastpix_client/utils/security.rb', line 121

def self._parse_basic_auth_scheme(req, scheme)
  username = T.let('', String)
  password = T.let('', String)

  T.unsafe(scheme).fields.each do |scheme_field|
    metadata = scheme_field.metadata[:security]
    next if metadata.nil? || !metadata.include?(:field_name)

    field_name = metadata[:field_name]
    value = scheme.send(scheme_field.name)

    username = T.let(value, String) if field_name == 'username'
    password = T.let(value, String) if field_name == 'password'
  end

  data = "#{username}:#{password}".encode
  # Use strict_encode, because encode adds newlines after 60 chars
  # https://docs.ruby-lang.org/en/3.0/Base64.html#method-i-encode64
  req.headers['Authorization'] = "Basic #{Base64.strict_encode64(data)}"
end

._parse_security_option(req, option) ⇒ Object 



42
43
44
45
46
47
48
49
 
# File 'lib/fastpix_client/utils/security.rb', line 42

def self._parse_security_option(req, option)
  T.unsafe(option).fields.each do |opt_field|
    metadata = opt_field.metadata[:security]
    next if metadata.nil? || !metadata.include?(:scheme)

    _parse_security_scheme(req, metadata, option.send(opt_field.name))
  end
end

._parse_security_scheme(req, scheme_metadata, scheme) ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/fastpix_client/utils/security.rb', line 52

def self._parse_security_scheme(req, scheme_metadata, scheme)
  scheme_type = scheme_metadata[:type]
  sub_type = scheme_metadata[:sub_type]

  if scheme.respond_to? :fields
    if scheme_type == 'http' && sub_type == 'basic'
      _parse_basic_auth_scheme(req, scheme)
      return
    end

    T.unsafe(scheme).fields.each do |field|
      metadata = field.metadata[:security]
      next if metadata.nil? || metadata[:field_name].nil?

      value = scheme.send(field.name)
      _parse_security_scheme_value(req, scheme_metadata, metadata, T.cast(value, String))
    end
  else
    _parse_security_scheme_value(req, scheme_metadata, scheme_metadata, T.cast(scheme, String))
  end
end

._parse_security_scheme_value(req, scheme_metadata, security_metadata, value) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/fastpix_client/utils/security.rb', line 78

def self._parse_security_scheme_value(req, scheme_metadata, security_metadata, value)
  scheme_type = scheme_metadata[:type]
  sub_type = scheme_metadata[:sub_type]
  header_name = security_metadata[:field_name]

  case scheme_type
  when 'apiKey'
    _apply_api_key_scheme(req, sub_type, header_name, value)
  when 'openIdConnect', 'oauth2'
    req.headers[header_name] = _bearerize(value)
  when 'http'
    if sub_type == 'bearer'
      req.headers[header_name] = _bearerize(value)
    elsif sub_type != 'custom'
      raise ArgumentError, SECURITY_NOT_SUPPORTED
    end
  else
    raise ArgumentError, SECURITY_NOT_SUPPORTED
  end
end

._path_param_from_array(param) ⇒ Object 



52
53
54
55
56
57
58
 
# File 'lib/fastpix_client/utils/url.rb', line 52

def self._path_param_from_array(param)
  pp_vals = []
  param.each do |pp_val|
    pp_vals.append(pp_val.to_s)
  end
  pp_vals.join(',')
end

._path_param_from_hash(param_metadata, param) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/fastpix_client/utils/url.rb', line 60

def self._path_param_from_hash(param_metadata, param)
  pp_vals = []
  param.each do |pp_key, pp_val|
    value = val_to_string(pp_val)

    if param_metadata.fetch(:explode, false)
      pp_vals.append("#{pp_key}=#{value}")
    else
      pp_vals.append("#{pp_key},#{value}")
    end
  end
  pp_vals.join(',')
end

._path_param_from_object(param_metadata, f, param) ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/fastpix_client/utils/url.rb', line 74

def self._path_param_from_object(param_metadata, f, param)
  pp_vals = []
  attrs = T.unsafe(param).fields.filter { |field| field.name && param.respond_to?(field.name.to_sym) }.map(&:name)
  attrs.each do |attr|
    field = T.unsafe(param).field(attr)

    param_value_metadata = field.metadata[:path_param]

    next if param_value_metadata.nil?

    parm_name = param_value_metadata.fetch(:field_name, f.name)

    param_field_val = param.send(attr)

    if param_field_val.class.respond_to?(:enums)
      param_field_val = param_field_val.serialize
    elsif param_field_val.is_a? DateTime
      param_field_val = param_field_val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
    end
    if !field.nil? && ::Crystalline::Utils.nilable?(field.type) && param_field_val.nil?
      next
    elsif param_metadata.fetch(:explode, false)
      pp_vals.append("#{parm_name}=#{param_field_val}")
    else
      pp_vals.append("#{parm_name},#{param_field_val}")
    end
  end
  pp_vals.join(',')
end

._path_param_scalar(param) ⇒ Object 



104
105
106
107
108
109
110
111
 
# File 'lib/fastpix_client/utils/url.rb', line 104

def self._path_param_scalar(param)
  if param.class.respond_to?(:enums)
    param = T.cast(param, T::Enum).serialize
  elsif param.is_a? DateTime
    param = param.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
  end
  param.to_s
end

._populate_form(field_name, explode, obj, delimiter, &get_field_name_lambda) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/fastpix_client/utils/forms.rb', line 20

def self._populate_form(field_name, explode, obj, delimiter, &get_field_name_lambda)
  params = {}

  return params if obj.nil?

  if obj.respond_to? :fields
    _populate_form_from_object(params, field_name, explode, obj, delimiter, &get_field_name_lambda)
  elsif obj.is_a? Hash
    _populate_form_from_hash(params, field_name, explode, obj, delimiter)
  elsif obj.is_a? Array
    _populate_form_from_array(params, field_name, explode, obj, delimiter)
  else
    params[field_name] = val_to_string(obj)
  end
  params
end

._populate_form_from_array(params, field_name, explode, obj, delimiter) ⇒ Object

Populates form params from an Array (mutates ‘params`).



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/fastpix_client/utils/forms.rb', line 72

def self._populate_form_from_array(params, field_name, explode, obj, delimiter)
  items = []
  obj.each do |value|
    next if value.nil?

    if explode
      params[field_name] = [] unless params.key? field_name

      params[field_name].append(val_to_string(value))
    else
      items.append(val_to_string(value))
    end
  end
  params[field_name] = items.map(&:to_s).join(delimiter) unless items.empty?
end

._populate_form_from_hash(params, field_name, explode, obj, delimiter) ⇒ Object

Populates form params from a Hash (mutates ‘params`).



57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/fastpix_client/utils/forms.rb', line 57

def self._populate_form_from_hash(params, field_name, explode, obj, delimiter)
  items = []
  obj.each do |key, value|
    next if value.nil?

    if explode
      params[key] = val_to_string(value)
    else
      items.append("#{key}#{delimiter}#{val_to_string(value)}")
    end
  end
  params[field_name] = [items.join(delimiter)] unless items.empty?
end

._populate_form_from_object(params, field_name, explode, obj, delimiter, &get_field_name_lambda) ⇒ Object

Populates form params from a MetadataFields object (mutates ‘params`).



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/fastpix_client/utils/forms.rb', line 38

def self._populate_form_from_object(params, field_name, explode, obj, delimiter, &get_field_name_lambda)
  items = []
  T.unsafe(obj).fields.each do |obj_field|
    obj_field_name = get_field_name_lambda.call(obj_field)
    next if obj_field_name == ''

    val = obj.send(obj_field.name.to_sym)
    next if val.nil?

    if explode
      params[obj_field_name] = [val_to_string(val)]
    else
      items.append("#{obj_field_name}#{delimiter}#{val_to_string(val)}")
    end
  end
  params[field_name] = [items.join(delimiter)] unless items.empty?
end

._populate_from_globals(param_name, value, param_type, gbls) ⇒ Object 



160
161
162
163
164
165
166
 
# File 'lib/fastpix_client/utils/utils.rb', line 160

def self._populate_from_globals(param_name, value, param_type, gbls)
  if value.nil? && !gbls.nil?
    global_value = gbls.dig(:parameters, param_type.to_sym, param_name.to_sym)
    value = global_value if !global_value.nil?
  end
  value
end

._serialize_header(explode, obj) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/fastpix_client/utils/headers.rb', line 32

def self._serialize_header(explode, obj)
  return '' if obj.nil?

  if obj.respond_to? :fields
    _serialize_header_from_object(explode, obj)
  elsif obj.is_a? Hash
    _serialize_header_from_hash(explode, obj)
  elsif obj.is_a? Array
    obj.filter { |v| !v.nil? }.map { |v| val_to_string(v) }.join(',')
  else
    val_to_string(obj)
  end
end

._serialize_header_from_hash(explode, obj) ⇒ Object

Serializes a Hash into a header string (nil when empty).



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/fastpix_client/utils/headers.rb', line 71

def self._serialize_header_from_hash(explode, obj)
  items = []
  obj.each do |key, value|
    next if value.nil?

    if explode
      items.append("#{key}=#{val_to_string(value)}")
    else
      items.append(key)
      items.append(val_to_string(value))
    end
  end

  items.join(',') unless items.empty?
end

._serialize_header_from_object(explode, obj) ⇒ Object

Serializes a MetadataFields object into a header string (nil when empty).



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/fastpix_client/utils/headers.rb', line 47

def self._serialize_header_from_object(explode, obj)
  items = []
  T.unsafe(obj).fields.each do |obj_field|
    obj_param_metadata = obj_field.metadata[:header]
    next if obj_param_metadata.nil?

    obj_field_name = obj_param_metadata.fetch(:field_name, obj_field.name)
    next if obj_field_name == ''

    val = obj.send(obj_field.name)
    next if val.nil?

    if explode
      items.append("#{obj_field_name}=#{val_to_string(val)}")
    else
      items.append(obj_field_name)
      items.append(val_to_string(val))
    end
  end

  items.join(',') unless items.empty?
end

._substitute_path_param(path, param_metadata, f, f_name, serialization, param) ⇒ Object

Substitutes a single path param into the path, returning the updated path.



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/fastpix_client/utils/url.rb', line 31

def self._substitute_path_param(path, param_metadata, f, f_name, serialization, param)
  if serialization != ''
    serialized_params = _get_serialized_params(param_metadata, f_name, param)
    serialized_params.each do |k, v|
      path = path.sub("{#{k}}", v.join(', '))
    end
    return path
  end

  placeholder = "{#{param_metadata.fetch(:field_name, f.name)}}"
  if param.is_a? Array
    path.sub(placeholder, _path_param_from_array(param))
  elsif param.is_a? Hash
    path.sub(placeholder, _path_param_from_hash(param_metadata, param))
  elsif param.class.include?(::Crystalline::MetadataFields)
    path.sub(placeholder, _path_param_from_object(param_metadata, f, param))
  else
    path.sub(placeholder, _path_param_scalar(param))
  end
end

.configure_request_security(req, security) ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/fastpix_client/utils/security.rb', line 19

def self.configure_request_security(req, security)
  return if security.nil?
  T.unsafe(security).fields.each do |sec_field|
    value = security.send(sec_field.name)
    next if value.nil?

    metadata = sec_field.metadata[:security]
    next if metadata.nil?

    _parse_security_option(req, value) if metadata[:option]

    if metadata[:scheme]
      # Special case for basic auth which could be a flattened struct
      if metadata[:sub_type] == 'basic' && !value.respond_to?(:fields)
        _parse_security_scheme(req, metadata, security)
      else
        _parse_security_scheme(req, metadata, value)
      end
    end
  end
end

.date_from_iso_format(optional) ⇒ Object 



79
80
81
82
83
84
85
 
# File 'lib/fastpix_client/utils/utils.rb', line 79

def self.date_from_iso_format(optional)
  Kernel.lambda do |s|
    return nil if optional && s.nil?

    return Date.iso8601(s)
  end
end

.datetime_from_iso_format(optional) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/fastpix_client/utils/utils.rb', line 70

def self.datetime_from_iso_format(optional)
  Kernel.lambda do |s|
    return nil if optional && s.nil?

    return DateTime.strptime(s, '%Y-%m-%dT%H:%M:%S.%NZ')
  end
end

.encode_form(form) ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/fastpix_client/utils/utils.rb', line 120

def self.encode_form(form)
  payload = {}
  form.each do |field_name, field|
    field = T.must(field)
    if field.length == 2
      if field[0].nil?
        # Handle multiple values for the same field name (arrays)
        _add_form_payload_value(payload, field_name, field[1])
      else
        # Handle file uploads
        file_part = Faraday::Multipart::FilePart.new(
          StringIO.new(T.must(field[1])),
          'application/octet-stream',
          field[0]
        )

        # Handle multiple files for the same field name (arrays)
        _add_form_payload_value(payload, field_name, file_part)
      end
    elsif field.length == 3
      param_part = Faraday::Multipart::ParamPart.new(field[1].to_json, field[2])

      # Handle multiple values for the same field name (arrays)
      _add_form_payload_value(payload, field_name, param_part)
    end
  end
  payload
end

.enum_from_string(enum_type, optional) ⇒ Object 



91
92
93
94
95
96
97
 
# File 'lib/fastpix_client/utils/utils.rb', line 91

def self.enum_from_string(enum_type, optional)
  Kernel.lambda do |s|
    return nil if optional && s.nil?

    return enum_type.deserialize(s)
  end
end

.error_status?(status) ⇒ Boolean

Returns:

  • (Boolean) 


44
45
46
47
48
49
50
 
# File 'lib/fastpix_client/utils/utils.rb', line 44

def self.error_status?(status)
  status_major = status / 100
  return true if status_major == 4
  return true if status_major == 5

  false
end

.field_name(name) ⇒ Object 



100
101
102
 
# File 'lib/fastpix_client/utils/utils.rb', line 100

def self.field_name(name)
  T.let(proc { name }, T.proc.returns(String))
end

.generate_url(clazz, server_url, path, path_params, gbls = nil) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/fastpix_client/utils/url.rb', line 12

def self.generate_url(clazz, server_url, path, path_params, gbls = nil)
  T.unsafe(clazz).fields.each do |f|
    param_metadata = f.metadata[:path_param]
    next if param_metadata.nil?

    if param_metadata.fetch(:style, 'simple') == 'simple'
      param = path_params.send(f.name) if !path_params.nil?
      param = _populate_from_globals(f.name, param, 'pathParam', gbls)
    end

    f_name = param_metadata.fetch(:field_name, f.name)
    serialization = param_metadata.fetch(:serialization, '')
    path = _substitute_path_param(path, param_metadata, f, f_name, serialization, param)
  end

  server_url.delete_suffix('/') + path
end

.get_headers(headers_params, gbls = nil) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/fastpix_client/utils/headers.rb', line 16

def self.get_headers(headers_params, gbls = nil)
  return {} if headers_params.nil?

  headers = {}
  T.unsafe(headers_params).fields.each do |f|
    metadata = f.metadata[:header]
    next if metadata.nil?

    value = _populate_from_globals(f.name, headers_params&.send(f.name), 'header', gbls)
    value = _serialize_header(metadata.fetch(:explode, false), value)
    headers[metadata.fetch(:field_name, f.name)] = value if !T.must(value).empty?
  end
  headers
end

.get_query_params(clazz, query_params, url_override = nil, gbls = nil) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/fastpix_client/utils/query_params.rb', line 15

def self.get_query_params(clazz, query_params, url_override = nil, gbls = nil)
  parsed_params = T.let({}, T::Hash[T.any(String, Symbol), T::Array[String]])
  unless url_override.nil?
    parsed_url = URI.parse url_override
    URI.decode_www_form(parsed_url.query.to_s).each do |key, value|
      parsed_params[key] ||= []
      T.must(parsed_params[key]) << value
    end
  end
  params = T.let({}, T::Hash[T.any(String, Symbol), T::Array[String]])
  T.unsafe(clazz).fields.each do |f|
    request_metadata = f.metadata[:request]
    next if !request_metadata.nil?

    metadata = f.metadata[:query_param]
    next if metadata.nil?

    param_name = f.name
    value = query_params&.send(param_name.to_sym)
    value = _populate_from_globals(param_name, value, 'queryParam', gbls)

    f_name = metadata[:field_name]
    serialization = metadata.fetch(:serialization, '')
    if serialization != ''
      params = params.merge _get_serialized_params(
        metadata, f_name, value
      )
    else
      style = metadata.fetch(:style, 'form')
      case style
      when 'deepObject'
        params = params.merge _get_deep_object_query_params(
          metadata, f_name, value
        )
      when 'form'
        params = params.merge _get_delimited_query_params(
          metadata, f_name, value, ','
        )
      when 'pipeDelimited'
        params = params.merge _get_delimited_query_params(
          metadata, f_name, value, '|'
        )
      else
        raise ArgumentError, 'not yet implemented'
      end
    end
  end
  params.merge parsed_params
end

.match_content_type(content_type, pattern) ⇒ Object 



53
54
55
56
57
 
# File 'lib/fastpix_client/utils/utils.rb', line 53

def self.match_content_type(content_type, pattern)
  return true if content_type == pattern || ['*', '*/*'].include?(pattern)

  content_type.split(';').any? { |piece| pattern == piece.strip }
end

.match_status_code(status_code, status_codes) ⇒ Object 



60
61
62
63
64
65
66
67
 
# File 'lib/fastpix_client/utils/utils.rb', line 60

def self.match_status_code(status_code, status_codes)
  return true if status_codes.include? 'default'

  status_code = status_code.to_s
  status_codes.any? do |code|
    code == status_code || (code.downcase.end_with?('xx') && status_code[0] == code[0])
  end
end

.parse_field(field, data_class) ⇒ Object 



106
107
108
109
110
111
112
113
114
 
# File 'lib/fastpix_client/utils/utils.rb', line 106

def self.parse_field(field, data_class)
  field_metadata = field.metadata[:metadata_string]
  return nil if field_metadata.nil?

  field_value = data_class.send(field.name)
  return nil if field_value.nil?

  field_value
end

.serialize_content_type(media_type, request) ⇒ Object

Raises:

  • (ArgumentError) 


48
49
50
51
52
53
54
55
 
# File 'lib/fastpix_client/utils/request_bodies.rb', line 48

def self.serialize_content_type(media_type, request)
  return media_type, ::Crystalline.to_json(request), nil if media_type.match('^(application|text)\/([^+]+\+)*json.*')
  return serialize_multipart_form(media_type, request) if media_type.match('^multipart\/.*')
  return media_type, serialize_form_data(request), nil if media_type.match('^application\/x-www-form-urlencoded.*')
  return media_type, request, nil if request.is_a?(String) || request.is_a?(Array)

  raise ArgumentError, "invalid request body type #{request.class} for mediaType #{media_type}"
end

.serialize_form_data(data) ⇒ Object 



156
157
158
159
160
161
162
163
164
165
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
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/fastpix_client/utils/forms.rb', line 156

def self.serialize_form_data(data)
  get_form_field_name = lambda do |obj_field|
    obj_param_metadata = obj_field.metadata[:form]

    return T.let({}, T::Hash[T.any(String, Symbol), Object]) if obj_param_metadata.nil?

    return obj_param_metadata.fetch(:field_name, obj_field.name)
  end

  form = T.let({}, T::Hash[T.any(String, Symbol), Object])
  if data.respond_to? :fields
    T.unsafe(data).fields.each do |field|
      val = data.send(field.name)
      next if val.nil?

      metadata = field.metadata[:form]

      next if metadata.nil?

      field_name = metadata.fetch(:field_name, field.name)

      if metadata[:json]
        form[field_name] = ::Crystalline.to_json(val)
      else
        if metadata.fetch(:style, 'form') == 'form'
          form = form.merge(
            _populate_form(
              field_name, metadata.fetch(:explode, true), val, ',', &get_form_field_name
            )
          )
        else
          raise ArgumentError, "Invalid form style for field #{field.name}"
        end
      end
    end
  elsif data.is_a? Hash
    data.each do |key, value|
      form[key] = [val_to_string(value)]
    end
  else
    raise ArgumentError, "Invalid request body type #{data.class}"
  end

  form
end

.serialize_multipart_form(media_type, request) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/fastpix_client/utils/forms.rb', line 89

def self.serialize_multipart_form(media_type, request)
  form = []
  T.unsafe(request).fields.each do |field|
    val = request.send(field.name)
    next if val.nil?

    field_metadata = field.metadata[:multipart_form]
    next if field_metadata.nil?

    _append_multipart_field(form, field, field_metadata, val)
  end
  [media_type, nil, form]
end

.serialize_request_body(request, nullable, optional, request_field_name, serialization_method) ⇒ Object

Raises:

  • (ArgumentError) 


27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/fastpix_client/utils/request_bodies.rb', line 27

def self.serialize_request_body(request, nullable, optional, request_field_name, serialization_method)
  return ['', nil, nil] if request.nil? && !nullable && optional

  return serialize_content_type(SERIALIZATION_METHOD_TO_CONTENT_TYPE[serialization_method], request) if !request.respond_to?(:fields) || !request.respond_to?(request_field_name)

  request_val = request.send(request_field_name)

  request_metadata = T.let(nil, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]]))
  matched_field = T.unsafe(request).fields.find { |f| f.name == request_field_name }
  request_metadata = matched_field.metadata[:request] unless matched_field.nil?
  raise ArgumentError, 'invalid request type' if request_metadata.nil?

  serialize_content_type(
    request_metadata.fetch(:media_type, 'application/octet-stream'), request_val
  )
end

.template_url(url_with_params, params) ⇒ Object 



114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/fastpix_client/utils/url.rb', line 114

def self.template_url(url_with_params, params)
  params.each do |key, value|
    if value.class.respond_to? :enums
      val_str = T.cast(value, T::Enum).serialize
    else
      val_str = value
    end
    url_with_params = url_with_params.gsub("{#{key}}", val_str)
  end

  url_with_params
end

.val_to_string(val) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
 
# File 'lib/fastpix_client/utils/utils.rb', line 18

def self.val_to_string(val)
  if val.class.respond_to?(:enums)
    T.unsafe(val).serialize.to_s
  elsif val.is_a? DateTime
    val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
  else
    val.to_s

  end
end