Class: Algolia::IngestionClient

Inherits:
Object
  • Object
show all
Defined in:
lib/algolia/api/ingestion_client.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config = nil) ⇒ IngestionClient

Returns a new instance of IngestionClient.



7
8
9
10
11
12
13
 
# File 'lib/algolia/api/ingestion_client.rb', line 7

def initialize(config = nil)
  raise '`config` is missing.' if config.nil?
  raise '`app_id` is missing.' if config.app_id.nil? || config.app_id == ''
  raise '`api_key` is missing.' if config.api_key.nil? || config.api_key == ''

  @api_client = Algolia::ApiClient.new(config)
end

Instance Attribute Details

#api_client ⇒ Object

Returns the value of attribute api_client.



5
6
7
 
# File 'lib/algolia/api/ingestion_client.rb', line 5

def api_client
  @api_client
end

Class Method Details

.create(app_id, api_key, region = nil, opts = {}) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/algolia/api/ingestion_client.rb', line 15

def self.create(app_id, api_key, region = nil, opts = {})
  hosts = []
  regions = ['eu', 'us']

  if region.is_a?(Hash) && (opts.nil? || opts.empty?)
    opts = region
    region = nil
  end

  raise "`region` is required and must be one of the following: #{regions.join(', ')}" if region.nil? || !region.is_a?(String) || !regions.include?(region)

  hosts << Transport::StatefulHost.new('data.{region}.algolia.com'.sub!('{region}', region), accept: CallType::READ | CallType::WRITE)

  config = Algolia::Configuration.new(app_id, api_key, hosts, 'Ingestion', opts)
  create_with_config(config)
end

.create_with_config(config) ⇒ Object 



32
33
34
 
# File 'lib/algolia/api/ingestion_client.rb', line 32

def self.create_with_config(config)
  new(config)
end

Instance Method Details

#create_authentication(authentication_create, request_options = {}) ⇒ AuthenticationCreateResponse

Create a authentication. Create a authentication.

Parameters:

  • authentication_create (AuthenticationCreate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (AuthenticationCreateResponse) 


71
72
73
74
 
# File 'lib/algolia/api/ingestion_client.rb', line 71

def create_authentication(authentication_create, request_options = {})
  response = create_authentication_with_http_info(authentication_create, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::AuthenticationCreateResponse')
end

#create_authentication_with_http_info(authentication_create, request_options = {}) ⇒ Http::Response

Create a authentication. Create a authentication.

Parameters:

  • authentication_create (AuthenticationCreate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/algolia/api/ingestion_client.rb', line 41

def create_authentication_with_http_info(authentication_create, request_options = {})
  # verify the required parameter 'authentication_create' is set
  if @api_client.config.client_side_validation && authentication_create.nil?
    raise ArgumentError, "Parameter `authentication_create` is required when calling `create_authentication`."
  end

  path = '/1/authentications'
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(authentication_create)

  new_options = request_options.merge(
    :operation => :'IngestionClient.create_authentication',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#create_destination(destination_create, request_options = {}) ⇒ DestinationCreateResponse

Create a destination. Create a destination.

Parameters:

  • destination_create (DestinationCreate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (DestinationCreateResponse) 


111
112
113
114
 
# File 'lib/algolia/api/ingestion_client.rb', line 111

def create_destination(destination_create, request_options = {})
  response = create_destination_with_http_info(destination_create, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::DestinationCreateResponse')
end

#create_destination_with_http_info(destination_create, request_options = {}) ⇒ Http::Response

Create a destination. Create a destination.

Parameters:

  • destination_create (DestinationCreate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/algolia/api/ingestion_client.rb', line 81

def create_destination_with_http_info(destination_create, request_options = {})
  # verify the required parameter 'destination_create' is set
  if @api_client.config.client_side_validation && destination_create.nil?
    raise ArgumentError, "Parameter `destination_create` is required when calling `create_destination`."
  end

  path = '/1/destinations'
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(destination_create)

  new_options = request_options.merge(
    :operation => :'IngestionClient.create_destination',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#create_source(source_create, request_options = {}) ⇒ SourceCreateResponse

Create a source. Create a source.

Parameters:

  • source_create (SourceCreate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (SourceCreateResponse) 


151
152
153
154
 
# File 'lib/algolia/api/ingestion_client.rb', line 151

def create_source(source_create, request_options = {})
  response = create_source_with_http_info(source_create, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::SourceCreateResponse')
end

#create_source_with_http_info(source_create, request_options = {}) ⇒ Http::Response

Create a source. Create a source.

Parameters:

  • source_create (SourceCreate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/algolia/api/ingestion_client.rb', line 121

def create_source_with_http_info(source_create, request_options = {})
  # verify the required parameter 'source_create' is set
  if @api_client.config.client_side_validation && source_create.nil?
    raise ArgumentError, "Parameter `source_create` is required when calling `create_source`."
  end

  path = '/1/sources'
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(source_create)

  new_options = request_options.merge(
    :operation => :'IngestionClient.create_source',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#create_task(task_create, request_options = {}) ⇒ TaskCreateResponse

Create a task. Create a task.

Parameters:

  • task_create (TaskCreate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (TaskCreateResponse) 


191
192
193
194
 
# File 'lib/algolia/api/ingestion_client.rb', line 191

def create_task(task_create, request_options = {})
  response = create_task_with_http_info(task_create, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::TaskCreateResponse')
end

#create_task_with_http_info(task_create, request_options = {}) ⇒ Http::Response

Create a task. Create a task.

Parameters:

  • task_create (TaskCreate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/algolia/api/ingestion_client.rb', line 161

def create_task_with_http_info(task_create, request_options = {})
  # verify the required parameter 'task_create' is set
  if @api_client.config.client_side_validation && task_create.nil?
    raise ArgumentError, "Parameter `task_create` is required when calling `create_task`."
  end

  path = '/1/tasks'
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(task_create)

  new_options = request_options.merge(
    :operation => :'IngestionClient.create_task',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#custom_delete(path, parameters = nil, request_options = {}) ⇒ Object

Send requests to the Algolia REST API. This method allow you to send requests to the Algolia REST API.

Parameters:

  • path (String) —

    Path of the endpoint, anything after &quot;/1&quot; must be specified. (required)

  • parameters (Hash<String, Object>) (defaults to: nil) —

    Query parameters to apply to the current query.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Object) 


234
235
236
237
 
# File 'lib/algolia/api/ingestion_client.rb', line 234

def custom_delete(path, parameters = nil, request_options = {})
  response = custom_delete_with_http_info(path, parameters, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Object')
end

#custom_delete_with_http_info(path, parameters = nil, request_options = {}) ⇒ Http::Response

Send requests to the Algolia REST API. This method allow you to send requests to the Algolia REST API.

Parameters:

  • path (String) —

    Path of the endpoint, anything after &quot;/1&quot; must be specified. (required)

  • parameters (Hash<String, Object>) (defaults to: nil) —

    Query parameters to apply to the current query.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/algolia/api/ingestion_client.rb', line 202

def custom_delete_with_http_info(path, parameters = nil, request_options = {})
  # verify the required parameter 'path' is set
  if @api_client.config.client_side_validation && path.nil?
    raise ArgumentError, "Parameter `path` is required when calling `custom_delete`."
  end

  path = '/1{path}'.sub('{' + 'path' + '}', path.to_s)
  query_params = {}
  query_params = query_params.merge(parameters) unless parameters.nil?
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.custom_delete',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:DELETE, path, new_options)
end

#custom_get(path, parameters = nil, request_options = {}) ⇒ Object

Send requests to the Algolia REST API. This method allow you to send requests to the Algolia REST API.

Parameters:

  • path (String) —

    Path of the endpoint, anything after &quot;/1&quot; must be specified. (required)

  • parameters (Hash<String, Object>) (defaults to: nil) —

    Query parameters to apply to the current query.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Object) 


277
278
279
280
 
# File 'lib/algolia/api/ingestion_client.rb', line 277

def custom_get(path, parameters = nil, request_options = {})
  response = custom_get_with_http_info(path, parameters, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Object')
end

#custom_get_with_http_info(path, parameters = nil, request_options = {}) ⇒ Http::Response

Send requests to the Algolia REST API. This method allow you to send requests to the Algolia REST API.

Parameters:

  • path (String) —

    Path of the endpoint, anything after &quot;/1&quot; must be specified. (required)

  • parameters (Hash<String, Object>) (defaults to: nil) —

    Query parameters to apply to the current query.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/algolia/api/ingestion_client.rb', line 245

def custom_get_with_http_info(path, parameters = nil, request_options = {})
  # verify the required parameter 'path' is set
  if @api_client.config.client_side_validation && path.nil?
    raise ArgumentError, "Parameter `path` is required when calling `custom_get`."
  end

  path = '/1{path}'.sub('{' + 'path' + '}', path.to_s)
  query_params = {}
  query_params = query_params.merge(parameters) unless parameters.nil?
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.custom_get',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#custom_post(path, parameters = nil, body = nil, request_options = {}) ⇒ Object

Send requests to the Algolia REST API. This method allow you to send requests to the Algolia REST API.

Parameters:

  • path (String) —

    Path of the endpoint, anything after &quot;/1&quot; must be specified. (required)

  • parameters (Hash<String, Object>) (defaults to: nil) —

    Query parameters to apply to the current query.

  • body (Object) (defaults to: nil) —

    Parameters to send with the custom request.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Object) 


322
323
324
325
 
# File 'lib/algolia/api/ingestion_client.rb', line 322

def custom_post(path, parameters = nil, body = nil, request_options = {})
  response = custom_post_with_http_info(path, parameters, body, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Object')
end

#custom_post_with_http_info(path, parameters = nil, body = nil, request_options = {}) ⇒ Http::Response

Send requests to the Algolia REST API. This method allow you to send requests to the Algolia REST API.

Parameters:

  • path (String) —

    Path of the endpoint, anything after &quot;/1&quot; must be specified. (required)

  • parameters (Hash<String, Object>) (defaults to: nil) —

    Query parameters to apply to the current query.

  • body (Object) (defaults to: nil) —

    Parameters to send with the custom request.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
 
# File 'lib/algolia/api/ingestion_client.rb', line 289

def custom_post_with_http_info(path, parameters = nil, body = nil, request_options = {})
  # verify the required parameter 'path' is set
  if @api_client.config.client_side_validation && path.nil?
    raise ArgumentError, "Parameter `path` is required when calling `custom_post`."
  end

  path = '/1{path}'.sub('{' + 'path' + '}', path.to_s)
  query_params = {}
  query_params = query_params.merge(parameters) unless parameters.nil?
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(body)

  new_options = request_options.merge(
    :operation => :'IngestionClient.custom_post',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#custom_put(path, parameters = nil, body = nil, request_options = {}) ⇒ Object

Send requests to the Algolia REST API. This method allow you to send requests to the Algolia REST API.

Parameters:

  • path (String) —

    Path of the endpoint, anything after &quot;/1&quot; must be specified. (required)

  • parameters (Hash<String, Object>) (defaults to: nil) —

    Query parameters to apply to the current query.

  • body (Object) (defaults to: nil) —

    Parameters to send with the custom request.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Object) 


367
368
369
370
 
# File 'lib/algolia/api/ingestion_client.rb', line 367

def custom_put(path, parameters = nil, body = nil, request_options = {})
  response = custom_put_with_http_info(path, parameters, body, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Object')
end

#custom_put_with_http_info(path, parameters = nil, body = nil, request_options = {}) ⇒ Http::Response

Send requests to the Algolia REST API. This method allow you to send requests to the Algolia REST API.

Parameters:

  • path (String) —

    Path of the endpoint, anything after &quot;/1&quot; must be specified. (required)

  • parameters (Hash<String, Object>) (defaults to: nil) —

    Query parameters to apply to the current query.

  • body (Object) (defaults to: nil) —

    Parameters to send with the custom request.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
 
# File 'lib/algolia/api/ingestion_client.rb', line 334

def custom_put_with_http_info(path, parameters = nil, body = nil, request_options = {})
  # verify the required parameter 'path' is set
  if @api_client.config.client_side_validation && path.nil?
    raise ArgumentError, "Parameter `path` is required when calling `custom_put`."
  end

  path = '/1{path}'.sub('{' + 'path' + '}', path.to_s)
  query_params = {}
  query_params = query_params.merge(parameters) unless parameters.nil?
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(body)

  new_options = request_options.merge(
    :operation => :'IngestionClient.custom_put',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:PUT, path, new_options)
end

#delete_authentication(authentication_id, request_options = {}) ⇒ DeleteResponse

Delete a authentication. Soft delete the authentication of the given authenticationID.

Parameters:

  • authentication_id (String) —

    The authentication UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (DeleteResponse) 


407
408
409
410
 
# File 'lib/algolia/api/ingestion_client.rb', line 407

def delete_authentication(authentication_id, request_options = {})
  response = delete_authentication_with_http_info(authentication_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::DeleteResponse')
end

#delete_authentication_with_http_info(authentication_id, request_options = {}) ⇒ Http::Response

Delete a authentication. Soft delete the authentication of the given authenticationID.

Parameters:

  • authentication_id (String) —

    The authentication UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
 
# File 'lib/algolia/api/ingestion_client.rb', line 377

def delete_authentication_with_http_info(authentication_id, request_options = {})
  # verify the required parameter 'authentication_id' is set
  if @api_client.config.client_side_validation && authentication_id.nil?
    raise ArgumentError, "Parameter `authentication_id` is required when calling `delete_authentication`."
  end

  path = '/1/authentications/{authenticationID}'.sub('{' + 'authenticationID' + '}', @api_client.encode_uri(authentication_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.delete_authentication',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:DELETE, path, new_options)
end

#delete_destination(destination_id, request_options = {}) ⇒ DeleteResponse

Delete a destination. Soft delete the destination of the given destinationID.

Parameters:

  • destination_id (String) —

    The destination UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (DeleteResponse) 


447
448
449
450
 
# File 'lib/algolia/api/ingestion_client.rb', line 447

def delete_destination(destination_id, request_options = {})
  response = delete_destination_with_http_info(destination_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::DeleteResponse')
end

#delete_destination_with_http_info(destination_id, request_options = {}) ⇒ Http::Response

Delete a destination. Soft delete the destination of the given destinationID.

Parameters:

  • destination_id (String) —

    The destination UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
 
# File 'lib/algolia/api/ingestion_client.rb', line 417

def delete_destination_with_http_info(destination_id, request_options = {})
  # verify the required parameter 'destination_id' is set
  if @api_client.config.client_side_validation && destination_id.nil?
    raise ArgumentError, "Parameter `destination_id` is required when calling `delete_destination`."
  end

  path = '/1/destinations/{destinationID}'.sub('{' + 'destinationID' + '}', @api_client.encode_uri(destination_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.delete_destination',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:DELETE, path, new_options)
end

#delete_source(source_id, request_options = {}) ⇒ DeleteResponse

Delete a source. Soft delete the source of the given sourceID.

Parameters:

  • source_id (String) —

    The source UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (DeleteResponse) 


487
488
489
490
 
# File 'lib/algolia/api/ingestion_client.rb', line 487

def delete_source(source_id, request_options = {})
  response = delete_source_with_http_info(source_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::DeleteResponse')
end

#delete_source_with_http_info(source_id, request_options = {}) ⇒ Http::Response

Delete a source. Soft delete the source of the given sourceID.

Parameters:

  • source_id (String) —

    The source UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
 
# File 'lib/algolia/api/ingestion_client.rb', line 457

def delete_source_with_http_info(source_id, request_options = {})
  # verify the required parameter 'source_id' is set
  if @api_client.config.client_side_validation && source_id.nil?
    raise ArgumentError, "Parameter `source_id` is required when calling `delete_source`."
  end

  path = '/1/sources/{sourceID}'.sub('{' + 'sourceID' + '}', @api_client.encode_uri(source_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.delete_source',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:DELETE, path, new_options)
end

#delete_task(task_id, request_options = {}) ⇒ DeleteResponse

Delete a task. Soft delete the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (DeleteResponse) 


527
528
529
530
 
# File 'lib/algolia/api/ingestion_client.rb', line 527

def delete_task(task_id, request_options = {})
  response = delete_task_with_http_info(task_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::DeleteResponse')
end

#delete_task_with_http_info(task_id, request_options = {}) ⇒ Http::Response

Delete a task. Soft delete the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
 
# File 'lib/algolia/api/ingestion_client.rb', line 497

def delete_task_with_http_info(task_id, request_options = {})
  # verify the required parameter 'task_id' is set
  if @api_client.config.client_side_validation && task_id.nil?
    raise ArgumentError, "Parameter `task_id` is required when calling `delete_task`."
  end

  path = '/1/tasks/{taskID}'.sub('{' + 'taskID' + '}', @api_client.encode_uri(task_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.delete_task',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:DELETE, path, new_options)
end

#disable_task(task_id, request_options = {}) ⇒ TaskUpdateResponse

Disable a task. Disable the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (TaskUpdateResponse) 


567
568
569
570
 
# File 'lib/algolia/api/ingestion_client.rb', line 567

def disable_task(task_id, request_options = {})
  response = disable_task_with_http_info(task_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::TaskUpdateResponse')
end

#disable_task_with_http_info(task_id, request_options = {}) ⇒ Http::Response

Disable a task. Disable the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
 
# File 'lib/algolia/api/ingestion_client.rb', line 537

def disable_task_with_http_info(task_id, request_options = {})
  # verify the required parameter 'task_id' is set
  if @api_client.config.client_side_validation && task_id.nil?
    raise ArgumentError, "Parameter `task_id` is required when calling `disable_task`."
  end

  path = '/1/tasks/{taskID}/disable'.sub('{' + 'taskID' + '}', @api_client.encode_uri(task_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.disable_task',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:PUT, path, new_options)
end

#enable_task(task_id, request_options = {}) ⇒ TaskUpdateResponse

Enable a task. Enable the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (TaskUpdateResponse) 


607
608
609
610
 
# File 'lib/algolia/api/ingestion_client.rb', line 607

def enable_task(task_id, request_options = {})
  response = enable_task_with_http_info(task_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::TaskUpdateResponse')
end

#enable_task_with_http_info(task_id, request_options = {}) ⇒ Http::Response

Enable a task. Enable the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
 
# File 'lib/algolia/api/ingestion_client.rb', line 577

def enable_task_with_http_info(task_id, request_options = {})
  # verify the required parameter 'task_id' is set
  if @api_client.config.client_side_validation && task_id.nil?
    raise ArgumentError, "Parameter `task_id` is required when calling `enable_task`."
  end

  path = '/1/tasks/{taskID}/enable'.sub('{' + 'taskID' + '}', @api_client.encode_uri(task_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.enable_task',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:PUT, path, new_options)
end

#get_authentication(authentication_id, request_options = {}) ⇒ Authentication

Get a authentication. Get the authentication of the given authenticationID.

Parameters:

  • authentication_id (String) —

    The authentication UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Authentication) 


647
648
649
650
 
# File 'lib/algolia/api/ingestion_client.rb', line 647

def get_authentication(authentication_id, request_options = {})
  response = get_authentication_with_http_info(authentication_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::Authentication')
end

#get_authentication_with_http_info(authentication_id, request_options = {}) ⇒ Http::Response

Get a authentication. Get the authentication of the given authenticationID.

Parameters:

  • authentication_id (String) —

    The authentication UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
 
# File 'lib/algolia/api/ingestion_client.rb', line 617

def get_authentication_with_http_info(authentication_id, request_options = {})
  # verify the required parameter 'authentication_id' is set
  if @api_client.config.client_side_validation && authentication_id.nil?
    raise ArgumentError, "Parameter `authentication_id` is required when calling `get_authentication`."
  end

  path = '/1/authentications/{authenticationID}'.sub('{' + 'authenticationID' + '}', @api_client.encode_uri(authentication_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_authentication',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_authentications(items_per_page = nil, page = nil, type = nil, platform = nil, sort = nil, order = nil, request_options = {}) ⇒ ListAuthenticationsResponse

Get a list of authentications. Get a list of authentications for the given query parameters, with pagination details.

Parameters:

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • type (Array<AuthenticationType>) (defaults to: nil) —

    The type of the authentications to retrieve.

  • platform (Array<PlatformWithNone>) (defaults to: nil) —

    The platform of the authentications to retrieve.

  • sort (AuthenticationSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (ListAuthenticationsResponse) 


698
699
700
701
 
# File 'lib/algolia/api/ingestion_client.rb', line 698

def get_authentications(items_per_page = nil, page = nil, type = nil, platform = nil, sort = nil, order = nil, request_options = {})
  response = get_authentications_with_http_info(items_per_page, page, type, platform, sort, order, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::ListAuthenticationsResponse')
end

#get_authentications_with_http_info(items_per_page = nil, page = nil, type = nil, platform = nil, sort = nil, order = nil, request_options = {}) ⇒ Http::Response

Get a list of authentications. Get a list of authentications for the given query parameters, with pagination details.

Parameters:

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • type (Array<AuthenticationType>) (defaults to: nil) —

    The type of the authentications to retrieve.

  • platform (Array<PlatformWithNone>) (defaults to: nil) —

    The platform of the authentications to retrieve.

  • sort (AuthenticationSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
 
# File 'lib/algolia/api/ingestion_client.rb', line 662

def get_authentications_with_http_info(items_per_page = nil, page = nil, type = nil, platform = nil, sort = nil, order = nil, request_options = {})
  path = '/1/authentications'
  query_params = {}
  query_params[:itemsPerPage] = items_per_page unless items_per_page.nil?
  query_params[:page] = page unless page.nil?
  query_params[:type] = @api_client.build_collection_param(type, :csv) unless type.nil?
  query_params[:platform] = @api_client.build_collection_param(platform, :csv) unless platform.nil?
  query_params[:sort] = sort unless sort.nil?
  query_params[:order] = order unless order.nil?
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_authentications',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_destination(destination_id, request_options = {}) ⇒ Destination

Get a destination. Get the destination of the given destinationID.

Parameters:

  • destination_id (String) —

    The destination UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Destination) 


738
739
740
741
 
# File 'lib/algolia/api/ingestion_client.rb', line 738

def get_destination(destination_id, request_options = {})
  response = get_destination_with_http_info(destination_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::Destination')
end

#get_destination_with_http_info(destination_id, request_options = {}) ⇒ Http::Response

Get a destination. Get the destination of the given destinationID.

Parameters:

  • destination_id (String) —

    The destination UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
 
# File 'lib/algolia/api/ingestion_client.rb', line 708

def get_destination_with_http_info(destination_id, request_options = {})
  # verify the required parameter 'destination_id' is set
  if @api_client.config.client_side_validation && destination_id.nil?
    raise ArgumentError, "Parameter `destination_id` is required when calling `get_destination`."
  end

  path = '/1/destinations/{destinationID}'.sub('{' + 'destinationID' + '}', @api_client.encode_uri(destination_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_destination',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_destinations(items_per_page = nil, page = nil, type = nil, authentication_id = nil, sort = nil, order = nil, request_options = {}) ⇒ ListDestinationsResponse

Get a list of destinations. Get a list of destinations for the given query parameters, with pagination details.

Parameters:

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • type (Array<DestinationType>) (defaults to: nil) —

    The type of the destinations to retrive.

  • authentication_id (Array<String>) (defaults to: nil) —

    The authenticationIDs of the destinations to retrive.

  • sort (DestinationSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (ListDestinationsResponse) 


789
790
791
792
 
# File 'lib/algolia/api/ingestion_client.rb', line 789

def get_destinations(items_per_page = nil, page = nil, type = nil, authentication_id = nil, sort = nil, order = nil, request_options = {})
  response = get_destinations_with_http_info(items_per_page, page, type, authentication_id, sort, order, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::ListDestinationsResponse')
end

#get_destinations_with_http_info(items_per_page = nil, page = nil, type = nil, authentication_id = nil, sort = nil, order = nil, request_options = {}) ⇒ Http::Response

Get a list of destinations. Get a list of destinations for the given query parameters, with pagination details.

Parameters:

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • type (Array<DestinationType>) (defaults to: nil) —

    The type of the destinations to retrive.

  • authentication_id (Array<String>) (defaults to: nil) —

    The authenticationIDs of the destinations to retrive.

  • sort (DestinationSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
 
# File 'lib/algolia/api/ingestion_client.rb', line 753

def get_destinations_with_http_info(items_per_page = nil, page = nil, type = nil, authentication_id = nil, sort = nil, order = nil, request_options = {})
  path = '/1/destinations'
  query_params = {}
  query_params[:itemsPerPage] = items_per_page unless items_per_page.nil?
  query_params[:page] = page unless page.nil?
  query_params[:type] = @api_client.build_collection_param(type, :csv) unless type.nil?
  query_params[:authenticationID] = @api_client.build_collection_param(authentication_id, :csv) unless authentication_id.nil?
  query_params[:sort] = sort unless sort.nil?
  query_params[:order] = order unless order.nil?
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_destinations',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_docker_source_streams(source_id, request_options = {}) ⇒ DockerSourceStreams

Retrieve a stream listing. Retrieve a stream listing for a given Singer specification compatible docker type source ID.

Parameters:

  • source_id (String) —

    The source UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (DockerSourceStreams) 


829
830
831
832
 
# File 'lib/algolia/api/ingestion_client.rb', line 829

def get_docker_source_streams(source_id, request_options = {})
  response = get_docker_source_streams_with_http_info(source_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::DockerSourceStreams')
end

#get_docker_source_streams_with_http_info(source_id, request_options = {}) ⇒ Http::Response

Retrieve a stream listing. Retrieve a stream listing for a given Singer specification compatible docker type source ID.

Parameters:

  • source_id (String) —

    The source UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
 
# File 'lib/algolia/api/ingestion_client.rb', line 799

def get_docker_source_streams_with_http_info(source_id, request_options = {})
  # verify the required parameter 'source_id' is set
  if @api_client.config.client_side_validation && source_id.nil?
    raise ArgumentError, "Parameter `source_id` is required when calling `get_docker_source_streams`."
  end

  path = '/1/sources/{sourceID}/discover'.sub('{' + 'sourceID' + '}', @api_client.encode_uri(source_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_docker_source_streams',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_event(run_id, event_id, request_options = {}) ⇒ Event

Get an event. Get a single event for a specific runID.

Parameters:

  • run_id (String) —

    The run UUID. (required)

  • event_id (String) —

    The event UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Event) 


875
876
877
878
 
# File 'lib/algolia/api/ingestion_client.rb', line 875

def get_event(run_id, event_id, request_options = {})
  response = get_event_with_http_info(run_id, event_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::Event')
end

#get_event_with_http_info(run_id, event_id, request_options = {}) ⇒ Http::Response

Get an event. Get a single event for a specific runID.

Parameters:

  • run_id (String) —

    The run UUID. (required)

  • event_id (String) —

    The event UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
 
# File 'lib/algolia/api/ingestion_client.rb', line 840

def get_event_with_http_info(run_id, event_id, request_options = {})
  # verify the required parameter 'run_id' is set
  if @api_client.config.client_side_validation && run_id.nil?
    raise ArgumentError, "Parameter `run_id` is required when calling `get_event`."
  end
  # verify the required parameter 'event_id' is set
  if @api_client.config.client_side_validation && event_id.nil?
    raise ArgumentError, "Parameter `event_id` is required when calling `get_event`."
  end

  path = '/1/runs/{runID}/events/{eventID}'.sub('{' + 'runID' + '}', @api_client.encode_uri(run_id.to_s)).sub('{' + 'eventID' + '}', @api_client.encode_uri(event_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_event',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_events(run_id, items_per_page = nil, page = nil, status = nil, type = nil, sort = nil, order = nil, start_date = nil, end_date = nil, request_options = {}) ⇒ ListEventsResponse

Get a list of events. Get a list of events associated to the given runID, for the given query parameters.

Parameters:

  • run_id (String) —

    The run UUID. (required)

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • status (Array<EventStatus>) (defaults to: nil) —

    Filter the status of the events.

  • type (Array<EventType>) (defaults to: nil) —

    Filter the type of the events.

  • sort (EventSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • start_date (String) (defaults to: nil) —

    The start date (in RFC3339 format) of the events fetching window. Defaults to &#39;now&#39;-3 hours if omitted.

  • end_date (String) (defaults to: nil) —

    The end date (in RFC3339 format) of the events fetching window. Defaults to &#39;now&#39; days if omitted.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (ListEventsResponse) 


940
941
942
943
 
# File 'lib/algolia/api/ingestion_client.rb', line 940

def get_events(run_id, items_per_page = nil, page = nil, status = nil, type = nil, sort = nil, order = nil, start_date = nil, end_date = nil, request_options = {})
  response = get_events_with_http_info(run_id, items_per_page, page, status, type, sort, order, start_date, end_date, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::ListEventsResponse')
end

#get_events_with_http_info(run_id, items_per_page = nil, page = nil, status = nil, type = nil, sort = nil, order = nil, start_date = nil, end_date = nil, request_options = {}) ⇒ Http::Response

Get a list of events. Get a list of events associated to the given runID, for the given query parameters.

Parameters:

  • run_id (String) —

    The run UUID. (required)

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • status (Array<EventStatus>) (defaults to: nil) —

    Filter the status of the events.

  • type (Array<EventType>) (defaults to: nil) —

    Filter the type of the events.

  • sort (EventSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • start_date (String) (defaults to: nil) —

    The start date (in RFC3339 format) of the events fetching window. Defaults to &#39;now&#39;-3 hours if omitted.

  • end_date (String) (defaults to: nil) —

    The end date (in RFC3339 format) of the events fetching window. Defaults to &#39;now&#39; days if omitted.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
 
# File 'lib/algolia/api/ingestion_client.rb', line 893

def get_events_with_http_info(run_id, items_per_page = nil, page = nil, status = nil, type = nil, sort = nil, order = nil, start_date = nil, end_date = nil,
                              request_options = {})
  # verify the required parameter 'run_id' is set
  if @api_client.config.client_side_validation && run_id.nil?
    raise ArgumentError, "Parameter `run_id` is required when calling `get_events`."
  end

  path = '/1/runs/{runID}/events'.sub('{' + 'runID' + '}', @api_client.encode_uri(run_id.to_s))
  query_params = {}
  query_params[:itemsPerPage] = items_per_page unless items_per_page.nil?
  query_params[:page] = page unless page.nil?
  query_params[:status] = @api_client.build_collection_param(status, :multi) unless status.nil?
  query_params[:type] = @api_client.build_collection_param(type, :multi) unless type.nil?
  query_params[:sort] = sort unless sort.nil?
  query_params[:order] = order unless order.nil?
  query_params[:startDate] = start_date unless start_date.nil?
  query_params[:endDate] = end_date unless end_date.nil?
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_events',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_run(run_id, request_options = {}) ⇒ Run

Get a run. Get a single run for the given ID.

Parameters:

  • run_id (String) —

    The run UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Run) 


980
981
982
983
 
# File 'lib/algolia/api/ingestion_client.rb', line 980

def get_run(run_id, request_options = {})
  response = get_run_with_http_info(run_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::Run')
end

#get_run_with_http_info(run_id, request_options = {}) ⇒ Http::Response

Get a run. Get a single run for the given ID.

Parameters:

  • run_id (String) —

    The run UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
 
# File 'lib/algolia/api/ingestion_client.rb', line 950

def get_run_with_http_info(run_id, request_options = {})
  # verify the required parameter 'run_id' is set
  if @api_client.config.client_side_validation && run_id.nil?
    raise ArgumentError, "Parameter `run_id` is required when calling `get_run`."
  end

  path = '/1/runs/{runID}'.sub('{' + 'runID' + '}', @api_client.encode_uri(run_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_run',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_runs(items_per_page = nil, page = nil, status = nil, task_id = nil, sort = nil, order = nil, start_date = nil, end_date = nil, request_options = {}) ⇒ RunListResponse

Get a list of runs. Get a list of runs for the given query parameters, with pagination details.

Parameters:

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • status (Array<RunStatus>) (defaults to: nil) —

    Filter the status of the runs.

  • task_id (String) (defaults to: nil) —

    Filter by taskID.

  • sort (RunSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • start_date (String) (defaults to: nil) —

    The start date (in RFC3339 format) of the runs fetching window. Defaults to &#39;now&#39;-7 days if omitted.

  • end_date (String) (defaults to: nil) —

    The end date (in RFC3339 format) of the runs fetching window. Defaults to &#39;now&#39; days if omitted.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (RunListResponse) 


1037
1038
1039
1040
 
# File 'lib/algolia/api/ingestion_client.rb', line 1037

def get_runs(items_per_page = nil, page = nil, status = nil, task_id = nil, sort = nil, order = nil, start_date = nil, end_date = nil, request_options = {})
  response = get_runs_with_http_info(items_per_page, page, status, task_id, sort, order, start_date, end_date, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::RunListResponse')
end

#get_runs_with_http_info(items_per_page = nil, page = nil, status = nil, task_id = nil, sort = nil, order = nil, start_date = nil, end_date = nil, request_options = {}) ⇒ Http::Response

Get a list of runs. Get a list of runs for the given query parameters, with pagination details.

Parameters:

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • status (Array<RunStatus>) (defaults to: nil) —

    Filter the status of the runs.

  • task_id (String) (defaults to: nil) —

    Filter by taskID.

  • sort (RunSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • start_date (String) (defaults to: nil) —

    The start date (in RFC3339 format) of the runs fetching window. Defaults to &#39;now&#39;-7 days if omitted.

  • end_date (String) (defaults to: nil) —

    The end date (in RFC3339 format) of the runs fetching window. Defaults to &#39;now&#39; days if omitted.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
 
# File 'lib/algolia/api/ingestion_client.rb', line 997

def get_runs_with_http_info(items_per_page = nil, page = nil, status = nil, task_id = nil, sort = nil, order = nil, start_date = nil, end_date = nil, request_options = {})
  path = '/1/runs'
  query_params = {}
  query_params[:itemsPerPage] = items_per_page unless items_per_page.nil?
  query_params[:page] = page unless page.nil?
  query_params[:status] = @api_client.build_collection_param(status, :multi) unless status.nil?
  query_params[:taskID] = task_id unless task_id.nil?
  query_params[:sort] = sort unless sort.nil?
  query_params[:order] = order unless order.nil?
  query_params[:startDate] = start_date unless start_date.nil?
  query_params[:endDate] = end_date unless end_date.nil?
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_runs',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_source(source_id, request_options = {}) ⇒ Source

Get a source. Get the source of the given sourceID.

Parameters:

  • source_id (String) —

    The source UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Source) 


1077
1078
1079
1080
 
# File 'lib/algolia/api/ingestion_client.rb', line 1077

def get_source(source_id, request_options = {})
  response = get_source_with_http_info(source_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::Source')
end

#get_source_with_http_info(source_id, request_options = {}) ⇒ Http::Response

Get a source. Get the source of the given sourceID.

Parameters:

  • source_id (String) —

    The source UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
 
# File 'lib/algolia/api/ingestion_client.rb', line 1047

def get_source_with_http_info(source_id, request_options = {})
  # verify the required parameter 'source_id' is set
  if @api_client.config.client_side_validation && source_id.nil?
    raise ArgumentError, "Parameter `source_id` is required when calling `get_source`."
  end

  path = '/1/sources/{sourceID}'.sub('{' + 'sourceID' + '}', @api_client.encode_uri(source_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_source',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_sources(items_per_page = nil, page = nil, type = nil, authentication_id = nil, sort = nil, order = nil, request_options = {}) ⇒ ListSourcesResponse

Get a list of sources. Get a list of sources for the given query parameters, with pagination details.

Parameters:

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • type (Array<SourceType>) (defaults to: nil) —

    The type of the sources to retrieve.

  • authentication_id (Array<String>) (defaults to: nil) —

    The authenticationIDs of the sources to retrieve. &#39;none&#39; returns sources that doesn&#39;t have an authentication.

  • sort (SourceSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (ListSourcesResponse) 


1128
1129
1130
1131
 
# File 'lib/algolia/api/ingestion_client.rb', line 1128

def get_sources(items_per_page = nil, page = nil, type = nil, authentication_id = nil, sort = nil, order = nil, request_options = {})
  response = get_sources_with_http_info(items_per_page, page, type, authentication_id, sort, order, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::ListSourcesResponse')
end

#get_sources_with_http_info(items_per_page = nil, page = nil, type = nil, authentication_id = nil, sort = nil, order = nil, request_options = {}) ⇒ Http::Response

Get a list of sources. Get a list of sources for the given query parameters, with pagination details.

Parameters:

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • type (Array<SourceType>) (defaults to: nil) —

    The type of the sources to retrieve.

  • authentication_id (Array<String>) (defaults to: nil) —

    The authenticationIDs of the sources to retrieve. &#39;none&#39; returns sources that doesn&#39;t have an authentication.

  • sort (SourceSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
 
# File 'lib/algolia/api/ingestion_client.rb', line 1092

def get_sources_with_http_info(items_per_page = nil, page = nil, type = nil, authentication_id = nil, sort = nil, order = nil, request_options = {})
  path = '/1/sources'
  query_params = {}
  query_params[:itemsPerPage] = items_per_page unless items_per_page.nil?
  query_params[:page] = page unless page.nil?
  query_params[:type] = @api_client.build_collection_param(type, :csv) unless type.nil?
  query_params[:authenticationID] = @api_client.build_collection_param(authentication_id, :csv) unless authentication_id.nil?
  query_params[:sort] = sort unless sort.nil?
  query_params[:order] = order unless order.nil?
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_sources',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_task(task_id, request_options = {}) ⇒ Task

Get a task. Get the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Task) 


1168
1169
1170
1171
 
# File 'lib/algolia/api/ingestion_client.rb', line 1168

def get_task(task_id, request_options = {})
  response = get_task_with_http_info(task_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::Task')
end

#get_task_with_http_info(task_id, request_options = {}) ⇒ Http::Response

Get a task. Get the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
 
# File 'lib/algolia/api/ingestion_client.rb', line 1138

def get_task_with_http_info(task_id, request_options = {})
  # verify the required parameter 'task_id' is set
  if @api_client.config.client_side_validation && task_id.nil?
    raise ArgumentError, "Parameter `task_id` is required when calling `get_task`."
  end

  path = '/1/tasks/{taskID}'.sub('{' + 'taskID' + '}', @api_client.encode_uri(task_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_task',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#get_tasks(items_per_page = nil, page = nil, action = nil, enabled = nil, source_id = nil, destination_id = nil, trigger_type = nil, sort = nil, order = nil, request_options = {}) ⇒ ListTasksResponse

Get a list of tasks. Get a list of tasks for the given query parameters, with pagination details.

Parameters:

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • action (Array<ActionType>) (defaults to: nil) —

    The action of the tasks to retrieve.

  • enabled (Boolean) (defaults to: nil) —

    Whether the task is enabled or not.

  • source_id (Array<String>) (defaults to: nil) —

    The sourceIDs of the tasks to retrive.

  • destination_id (Array<String>) (defaults to: nil) —

    The destinationIDs of the tasks to retrive.

  • trigger_type (Array<TriggerType>) (defaults to: nil) —

    The trigger type of the task.

  • sort (TaskSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (ListTasksResponse) 


1229
1230
1231
1232
1233
 
# File 'lib/algolia/api/ingestion_client.rb', line 1229

def get_tasks(items_per_page = nil, page = nil, action = nil, enabled = nil, source_id = nil, destination_id = nil, trigger_type = nil, sort = nil, order = nil,
              request_options = {})
  response = get_tasks_with_http_info(items_per_page, page, action, enabled, source_id, destination_id, trigger_type, sort, order, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::ListTasksResponse')
end

#get_tasks_with_http_info(items_per_page = nil, page = nil, action = nil, enabled = nil, source_id = nil, destination_id = nil, trigger_type = nil, sort = nil, order = nil, request_options = {}) ⇒ Http::Response

Get a list of tasks. Get a list of tasks for the given query parameters, with pagination details.

Parameters:

  • items_per_page (Integer) (defaults to: nil) —

    The number of items per page to return.

  • page (Integer) (defaults to: nil) —

    The page number to fetch, starting at 1.

  • action (Array<ActionType>) (defaults to: nil) —

    The action of the tasks to retrieve.

  • enabled (Boolean) (defaults to: nil) —

    Whether the task is enabled or not.

  • source_id (Array<String>) (defaults to: nil) —

    The sourceIDs of the tasks to retrive.

  • destination_id (Array<String>) (defaults to: nil) —

    The destinationIDs of the tasks to retrive.

  • trigger_type (Array<TriggerType>) (defaults to: nil) —

    The trigger type of the task.

  • sort (TaskSortKeys) (defaults to: nil) —

    The key by which the list should be sorted.

  • order (OrderKeys) (defaults to: nil) —

    The order of the returned list.

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
 
# File 'lib/algolia/api/ingestion_client.rb', line 1186

def get_tasks_with_http_info(items_per_page = nil, page = nil, action = nil, enabled = nil, source_id = nil, destination_id = nil, trigger_type = nil, sort = nil, order = nil,
                             request_options = {})
  path = '/1/tasks'
  query_params = {}
  query_params[:itemsPerPage] = items_per_page unless items_per_page.nil?
  query_params[:page] = page unless page.nil?
  query_params[:action] = @api_client.build_collection_param(action, :csv) unless action.nil?
  query_params[:enabled] = enabled unless enabled.nil?
  query_params[:sourceID] = @api_client.build_collection_param(source_id, :csv) unless source_id.nil?
  query_params[:destinationID] = @api_client.build_collection_param(destination_id, :csv) unless destination_id.nil?
  query_params[:triggerType] = @api_client.build_collection_param(trigger_type, :csv) unless trigger_type.nil?
  query_params[:sort] = sort unless sort.nil?
  query_params[:order] = order unless order.nil?
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.get_tasks',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:GET, path, new_options)
end

#run_task(task_id, request_options = {}) ⇒ RunResponse

Run a task. Run the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (RunResponse) 


1270
1271
1272
1273
 
# File 'lib/algolia/api/ingestion_client.rb', line 1270

def run_task(task_id, request_options = {})
  response = run_task_with_http_info(task_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::RunResponse')
end

#run_task_with_http_info(task_id, request_options = {}) ⇒ Http::Response

Run a task. Run the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
 
# File 'lib/algolia/api/ingestion_client.rb', line 1240

def run_task_with_http_info(task_id, request_options = {})
  # verify the required parameter 'task_id' is set
  if @api_client.config.client_side_validation && task_id.nil?
    raise ArgumentError, "Parameter `task_id` is required when calling `run_task`."
  end

  path = '/1/tasks/{taskID}/run'.sub('{' + 'taskID' + '}', @api_client.encode_uri(task_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.run_task',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#search_authentications(authentication_search, request_options = {}) ⇒ Array<Authentication>

Search among authentications. Search among authentications with a defined set of parameters.

Parameters:

  • authentication_search (AuthenticationSearch) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Array<Authentication>) 


1310
1311
1312
1313
 
# File 'lib/algolia/api/ingestion_client.rb', line 1310

def search_authentications(authentication_search, request_options = {})
  response = search_authentications_with_http_info(authentication_search, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Array<Ingestion::Authentication>')
end

#search_authentications_with_http_info(authentication_search, request_options = {}) ⇒ Http::Response

Search among authentications. Search among authentications with a defined set of parameters.

Parameters:

  • authentication_search (AuthenticationSearch) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
 
# File 'lib/algolia/api/ingestion_client.rb', line 1280

def search_authentications_with_http_info(authentication_search, request_options = {})
  # verify the required parameter 'authentication_search' is set
  if @api_client.config.client_side_validation && authentication_search.nil?
    raise ArgumentError, "Parameter `authentication_search` is required when calling `search_authentications`."
  end

  path = '/1/authentications/search'
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(authentication_search)

  new_options = request_options.merge(
    :operation => :'IngestionClient.search_authentications',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#search_destinations(destination_search, request_options = {}) ⇒ Array<Destination>

Search among destinations. Search among destinations with a defined set of parameters.

Parameters:

  • destination_search (DestinationSearch) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Array<Destination>) 


1350
1351
1352
1353
 
# File 'lib/algolia/api/ingestion_client.rb', line 1350

def search_destinations(destination_search, request_options = {})
  response = search_destinations_with_http_info(destination_search, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Array<Ingestion::Destination>')
end

#search_destinations_with_http_info(destination_search, request_options = {}) ⇒ Http::Response

Search among destinations. Search among destinations with a defined set of parameters.

Parameters:

  • destination_search (DestinationSearch) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
 
# File 'lib/algolia/api/ingestion_client.rb', line 1320

def search_destinations_with_http_info(destination_search, request_options = {})
  # verify the required parameter 'destination_search' is set
  if @api_client.config.client_side_validation && destination_search.nil?
    raise ArgumentError, "Parameter `destination_search` is required when calling `search_destinations`."
  end

  path = '/1/destinations/search'
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(destination_search)

  new_options = request_options.merge(
    :operation => :'IngestionClient.search_destinations',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#search_sources(source_search, request_options = {}) ⇒ Array<Source>

Search among sources. Search among sources with a defined set of parameters.

Parameters:

  • source_search (SourceSearch) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Array<Source>) 


1390
1391
1392
1393
 
# File 'lib/algolia/api/ingestion_client.rb', line 1390

def search_sources(source_search, request_options = {})
  response = search_sources_with_http_info(source_search, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Array<Ingestion::Source>')
end

#search_sources_with_http_info(source_search, request_options = {}) ⇒ Http::Response

Search among sources. Search among sources with a defined set of parameters.

Parameters:

  • source_search (SourceSearch) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
 
# File 'lib/algolia/api/ingestion_client.rb', line 1360

def search_sources_with_http_info(source_search, request_options = {})
  # verify the required parameter 'source_search' is set
  if @api_client.config.client_side_validation && source_search.nil?
    raise ArgumentError, "Parameter `source_search` is required when calling `search_sources`."
  end

  path = '/1/sources/search'
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(source_search)

  new_options = request_options.merge(
    :operation => :'IngestionClient.search_sources',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#search_tasks(task_search, request_options = {}) ⇒ Array<Task>

Search among tasks. Search among tasks with a defined set of parameters.

Parameters:

  • task_search (TaskSearch) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (Array<Task>) 


1430
1431
1432
1433
 
# File 'lib/algolia/api/ingestion_client.rb', line 1430

def search_tasks(task_search, request_options = {})
  response = search_tasks_with_http_info(task_search, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Array<Ingestion::Task>')
end

#search_tasks_with_http_info(task_search, request_options = {}) ⇒ Http::Response

Search among tasks. Search among tasks with a defined set of parameters.

Parameters:

  • task_search (TaskSearch) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
 
# File 'lib/algolia/api/ingestion_client.rb', line 1400

def search_tasks_with_http_info(task_search, request_options = {})
  # verify the required parameter 'task_search' is set
  if @api_client.config.client_side_validation && task_search.nil?
    raise ArgumentError, "Parameter `task_search` is required when calling `search_tasks`."
  end

  path = '/1/tasks/search'
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(task_search)

  new_options = request_options.merge(
    :operation => :'IngestionClient.search_tasks',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#trigger_docker_source_discover(source_id, request_options = {}) ⇒ DockerSourceDiscover

Trigger a stream listing request. Trigger a stream listing request for a Singer specification compatible docker type source.

Parameters:

  • source_id (String) —

    The source UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (DockerSourceDiscover) 


1470
1471
1472
1473
 
# File 'lib/algolia/api/ingestion_client.rb', line 1470

def trigger_docker_source_discover(source_id, request_options = {})
  response = trigger_docker_source_discover_with_http_info(source_id, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::DockerSourceDiscover')
end

#trigger_docker_source_discover_with_http_info(source_id, request_options = {}) ⇒ Http::Response

Trigger a stream listing request. Trigger a stream listing request for a Singer specification compatible docker type source.

Parameters:

  • source_id (String) —

    The source UUID. (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
 
# File 'lib/algolia/api/ingestion_client.rb', line 1440

def trigger_docker_source_discover_with_http_info(source_id, request_options = {})
  # verify the required parameter 'source_id' is set
  if @api_client.config.client_side_validation && source_id.nil?
    raise ArgumentError, "Parameter `source_id` is required when calling `trigger_docker_source_discover`."
  end

  path = '/1/sources/{sourceID}/discover'.sub('{' + 'sourceID' + '}', @api_client.encode_uri(source_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body]

  new_options = request_options.merge(
    :operation => :'IngestionClient.trigger_docker_source_discover',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:POST, path, new_options)
end

#update_authentication(authentication_id, authentication_update, request_options = {}) ⇒ AuthenticationUpdateResponse

Update a authentication. Update the authentication of the given authenticationID.

Parameters:

  • authentication_id (String) —

    The authentication UUID. (required)

  • authentication_update (AuthenticationUpdate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (AuthenticationUpdateResponse) 


1516
1517
1518
1519
 
# File 'lib/algolia/api/ingestion_client.rb', line 1516

def update_authentication(authentication_id, authentication_update, request_options = {})
  response = update_authentication_with_http_info(authentication_id, authentication_update, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::AuthenticationUpdateResponse')
end

#update_authentication_with_http_info(authentication_id, authentication_update, request_options = {}) ⇒ Http::Response

Update a authentication. Update the authentication of the given authenticationID.

Parameters:

  • authentication_id (String) —

    The authentication UUID. (required)

  • authentication_update (AuthenticationUpdate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
 
# File 'lib/algolia/api/ingestion_client.rb', line 1481

def update_authentication_with_http_info(authentication_id, authentication_update, request_options = {})
  # verify the required parameter 'authentication_id' is set
  if @api_client.config.client_side_validation && authentication_id.nil?
    raise ArgumentError, "Parameter `authentication_id` is required when calling `update_authentication`."
  end
  # verify the required parameter 'authentication_update' is set
  if @api_client.config.client_side_validation && authentication_update.nil?
    raise ArgumentError, "Parameter `authentication_update` is required when calling `update_authentication`."
  end

  path = '/1/authentications/{authenticationID}'.sub('{' + 'authenticationID' + '}', @api_client.encode_uri(authentication_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(authentication_update)

  new_options = request_options.merge(
    :operation => :'IngestionClient.update_authentication',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:PATCH, path, new_options)
end

#update_destination(destination_id, destination_update, request_options = {}) ⇒ DestinationUpdateResponse

Update a destination. Update the destination of the given destinationID.

Parameters:

  • destination_id (String) —

    The destination UUID. (required)

  • destination_update (DestinationUpdate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (DestinationUpdateResponse) 


1562
1563
1564
1565
 
# File 'lib/algolia/api/ingestion_client.rb', line 1562

def update_destination(destination_id, destination_update, request_options = {})
  response = update_destination_with_http_info(destination_id, destination_update, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::DestinationUpdateResponse')
end

#update_destination_with_http_info(destination_id, destination_update, request_options = {}) ⇒ Http::Response

Update a destination. Update the destination of the given destinationID.

Parameters:

  • destination_id (String) —

    The destination UUID. (required)

  • destination_update (DestinationUpdate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
 
# File 'lib/algolia/api/ingestion_client.rb', line 1527

def update_destination_with_http_info(destination_id, destination_update, request_options = {})
  # verify the required parameter 'destination_id' is set
  if @api_client.config.client_side_validation && destination_id.nil?
    raise ArgumentError, "Parameter `destination_id` is required when calling `update_destination`."
  end
  # verify the required parameter 'destination_update' is set
  if @api_client.config.client_side_validation && destination_update.nil?
    raise ArgumentError, "Parameter `destination_update` is required when calling `update_destination`."
  end

  path = '/1/destinations/{destinationID}'.sub('{' + 'destinationID' + '}', @api_client.encode_uri(destination_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(destination_update)

  new_options = request_options.merge(
    :operation => :'IngestionClient.update_destination',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:PATCH, path, new_options)
end

#update_source(source_id, source_update, request_options = {}) ⇒ SourceUpdateResponse

Update a source. Update the source of the given sourceID.

Parameters:

  • source_id (String) —

    The source UUID. (required)

  • source_update (SourceUpdate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (SourceUpdateResponse) 


1608
1609
1610
1611
 
# File 'lib/algolia/api/ingestion_client.rb', line 1608

def update_source(source_id, source_update, request_options = {})
  response = update_source_with_http_info(source_id, source_update, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::SourceUpdateResponse')
end

#update_source_with_http_info(source_id, source_update, request_options = {}) ⇒ Http::Response

Update a source. Update the source of the given sourceID.

Parameters:

  • source_id (String) —

    The source UUID. (required)

  • source_update (SourceUpdate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
 
# File 'lib/algolia/api/ingestion_client.rb', line 1573

def update_source_with_http_info(source_id, source_update, request_options = {})
  # verify the required parameter 'source_id' is set
  if @api_client.config.client_side_validation && source_id.nil?
    raise ArgumentError, "Parameter `source_id` is required when calling `update_source`."
  end
  # verify the required parameter 'source_update' is set
  if @api_client.config.client_side_validation && source_update.nil?
    raise ArgumentError, "Parameter `source_update` is required when calling `update_source`."
  end

  path = '/1/sources/{sourceID}'.sub('{' + 'sourceID' + '}', @api_client.encode_uri(source_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(source_update)

  new_options = request_options.merge(
    :operation => :'IngestionClient.update_source',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:PATCH, path, new_options)
end

#update_task(task_id, task_update, request_options = {}) ⇒ TaskUpdateResponse

Update a task. Update the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • task_update (TaskUpdate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:

  • (TaskUpdateResponse) 


1654
1655
1656
1657
 
# File 'lib/algolia/api/ingestion_client.rb', line 1654

def update_task(task_id, task_update, request_options = {})
  response = update_task_with_http_info(task_id, task_update, request_options)
  deserialize(response.body, request_options[:debug_return_type] || 'Ingestion::TaskUpdateResponse')
end

#update_task_with_http_info(task_id, task_update, request_options = {}) ⇒ Http::Response

Update a task. Update the task of the given taskID.

Parameters:

  • task_id (String) —

    The task UUID. (required)

  • task_update (TaskUpdate) —

    (required)

  • request_options: —

    The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)

Returns:



1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
 
# File 'lib/algolia/api/ingestion_client.rb', line 1619

def update_task_with_http_info(task_id, task_update, request_options = {})
  # verify the required parameter 'task_id' is set
  if @api_client.config.client_side_validation && task_id.nil?
    raise ArgumentError, "Parameter `task_id` is required when calling `update_task`."
  end
  # verify the required parameter 'task_update' is set
  if @api_client.config.client_side_validation && task_update.nil?
    raise ArgumentError, "Parameter `task_update` is required when calling `update_task`."
  end

  path = '/1/tasks/{taskID}'.sub('{' + 'taskID' + '}', @api_client.encode_uri(task_id.to_s))
  query_params = {}
  query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
  header_params = {}
  header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?

  post_body = request_options[:debug_body] || @api_client.object_to_http_body(task_update)

  new_options = request_options.merge(
    :operation => :'IngestionClient.update_task',
    :header_params => header_params,
    :query_params => query_params,
    :body => post_body,
    :use_read_transporter => false
  )

  @api_client.call_api(:PATCH, path, new_options)
end