Class: Candid::PreEncounter::Coverages::V1::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/candid/pre_encounter/coverages/v_1/client.rb

Instance Method Summary collapse

Constructor Details

#initialize(client:, base_url: nil, environment: nil) ⇒ void

Parameters:



13
14
15
16
17
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 13

def initialize(client:, base_url: nil, environment: nil)
  @client = client
  @base_url = base_url
  @environment = environment
end

Instance Method Details

#batch_update_ppg(request_options: {}, **params) ⇒ untyped

Finds all coverages associated with the given ppg_id and updates the ppg_fields for each coverage.

Parameters:

Options Hash (request_options:):

  • :base_url (String)
  • :additional_headers (Hash{String => Object})
  • :additional_query_parameters (Hash{String => Object})
  • :additional_body_parameters (Hash{String => Object})
  • :timeout_in_seconds (Integer)

Options Hash (**params):

Returns:

  • (untyped)

Raises:

  • (error_class) 


326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 326

def batch_update_ppg(request_options: {}, **params)
  params = Candid::Internal::Types::Utils.normalize_keys(params)
  request = Candid::Internal::JSON::Request.new(
    base_url: request_options[:base_url] || @base_url || @environment&.dig(:pre_encounter),
    method: "POST",
    path: "/coverages/v1/batch-update-ppg/#{params[:ppg_id]}",
    body: Candid::PreEncounter::Coverages::V1::Types::PayerPlanGroupFields.new(params).to_h,
    request_options: request_options
  )
  begin
    response = @client.send(request)
  rescue Net::HTTPRequestTimeout
    raise Candid::Errors::TimeoutError
  end
  code = response.code.to_i
  return if code.between?(200, 299)

  error_class = Candid::Errors::ResponseError.subclass_for_code(code)
  raise error_class.new(response.body, code: code)
end

#check_eligibility(request_options: {}, **params) ⇒ Candid::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckMetadata

Initiates an eligibility check. Returns the metadata of the check if successfully initiated.

Parameters:

Options Hash (request_options:):

  • :base_url (String)
  • :additional_headers (Hash{String => Object})
  • :additional_query_parameters (Hash{String => Object})
  • :additional_body_parameters (Hash{String => Object})
  • :timeout_in_seconds (Integer)

Options Hash (**params):

Returns:



359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 359

def check_eligibility(request_options: {}, **params)
  params = Candid::Internal::Types::Utils.normalize_keys(params)
  request_data = Candid::PreEncounter::Coverages::V1::Types::CheckEligibilityRequest.new(params).to_h
  non_body_param_names = ["id"]
  body = request_data.except(*non_body_param_names)

  request = Candid::Internal::JSON::Request.new(
    base_url: request_options[:base_url] || @base_url || @environment&.dig(:pre_encounter),
    method: "POST",
    path: "/coverages/v1/#{params[:id]}/eligibility",
    body: body,
    request_options: request_options
  )
  begin
    response = @client.send(request)
  rescue Net::HTTPRequestTimeout
    raise Candid::Errors::TimeoutError
  end
  code = response.code.to_i
  if code.between?(200, 299)
    Candid::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckMetadata.load(response.body)
  else
    error_class = Candid::Errors::ResponseError.subclass_for_code(code)
    raise error_class.new(response.body, code: code)
  end
end

#create(request_options: {}, **params) ⇒ Candid::PreEncounter::Coverages::V1::Types::Coverage

Creates a new Coverage. A Coverage provides the high-level identifiers and descriptors of a specific insurance plan for a specific individual - typically the information you can find on an insurance card. Additionally a coverage will include detailed benefits information covered by the specific plan for the individual.

Parameters:

Options Hash (request_options:):

  • :base_url (String)
  • :additional_headers (Hash{String => Object})
  • :additional_query_parameters (Hash{String => Object})
  • :additional_body_parameters (Hash{String => Object})
  • :timeout_in_seconds (Integer)

Returns:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 33

def create(request_options: {}, **params)
  params = Candid::Internal::Types::Utils.normalize_keys(params)
  request = Candid::Internal::JSON::Request.new(
    base_url: request_options[:base_url] || @base_url || @environment&.dig(:pre_encounter),
    method: "POST",
    path: "/coverages/v1",
    body: Candid::PreEncounter::Coverages::V1::Types::MutableCoverage.new(params).to_h,
    request_options: request_options
  )
  begin
    response = @client.send(request)
  rescue Net::HTTPRequestTimeout
    raise Candid::Errors::TimeoutError
  end
  code = response.code.to_i
  if code.between?(200, 299)
    Candid::PreEncounter::Coverages::V1::Types::Coverage.load(response.body)
  else
    error_class = Candid::Errors::ResponseError.subclass_for_code(code)
    raise error_class.new(response.body, code: code)
  end
end

#get(request_options: {}, **params) ⇒ Candid::PreEncounter::Coverages::V1::Types::Coverage

gets a specific Coverage

Parameters:

  • request_options (Hash) (defaults to: {})
  • params (Hash)

Options Hash (request_options:):

  • :base_url (String)
  • :additional_headers (Hash{String => Object})
  • :additional_query_parameters (Hash{String => Object})
  • :additional_body_parameters (Hash{String => Object})
  • :timeout_in_seconds (Integer)

Options Hash (**params):

Returns:



152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 152

def get(request_options: {}, **params)
  params = Candid::Internal::Types::Utils.normalize_keys(params)
  request = Candid::Internal::JSON::Request.new(
    base_url: request_options[:base_url] || @base_url || @environment&.dig(:pre_encounter),
    method: "GET",
    path: "/coverages/v1/#{params[:id]}",
    request_options: request_options
  )
  begin
    response = @client.send(request)
  rescue Net::HTTPRequestTimeout
    raise Candid::Errors::TimeoutError
  end
  code = response.code.to_i
  if code.between?(200, 299)
    Candid::PreEncounter::Coverages::V1::Types::Coverage.load(response.body)
  else
    error_class = Candid::Errors::ResponseError.subclass_for_code(code)
    raise error_class.new(response.body, code: code)
  end
end

#get_eligibility(request_options: {}, **params) ⇒ Candid::PreEncounter::Coverages::V1::Types::CoverageEligibilityCheckResponse

Gets the eligibility of a patient for a specific coverage if successful.

Parameters:

  • request_options (Hash) (defaults to: {})
  • params (Hash)

Options Hash (request_options:):

  • :base_url (String)
  • :additional_headers (Hash{String => Object})
  • :additional_query_parameters (Hash{String => Object})
  • :additional_body_parameters (Hash{String => Object})
  • :timeout_in_seconds (Integer)

Options Hash (**params):

Returns:



399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 399

def get_eligibility(request_options: {}, **params)
  params = Candid::Internal::Types::Utils.normalize_keys(params)
  request = Candid::Internal::JSON::Request.new(
    base_url: request_options[:base_url] || @base_url || @environment&.dig(:pre_encounter),
    method: "GET",
    path: "/coverages/v1/#{params[:id]}/eligibility/#{params[:check_id]}",
    request_options: request_options
  )
  begin
    response = @client.send(request)
  rescue Net::HTTPRequestTimeout
    raise Candid::Errors::TimeoutError
  end
  code = response.code.to_i
  if code.between?(200, 299)
    Candid::PreEncounter::Coverages::V1::Types::CoverageEligibilityCheckResponse.load(response.body)
  else
    error_class = Candid::Errors::ResponseError.subclass_for_code(code)
    raise error_class.new(response.body, code: code)
  end
end

#get_history(request_options: {}, **params) ⇒ Array[Candid::PreEncounter::Coverages::V1::Types::Coverage]

Gets a coverage’s history. Full history is returned if no filters are defined. The return list is ordered by version, defaulting to ascending.

Parameters:

  • request_options (Hash) (defaults to: {})
  • params (Hash)

Options Hash (request_options:):

  • :base_url (String)
  • :additional_headers (Hash{String => Object})
  • :additional_query_parameters (Hash{String => Object})
  • :additional_body_parameters (Hash{String => Object})
  • :timeout_in_seconds (Integer)

Options Hash (**params):

Returns:

Raises:

  • (error_class) 


192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 192

def get_history(request_options: {}, **params)
  params = Candid::Internal::Types::Utils.normalize_keys(params)
  query_param_names = %i[start end_ non_auto_updated_coverages_only sort_direction limit]
  query_params = {}
  query_params["start"] = params[:start] if params.key?(:start)
  query_params["end"] = params[:end_] if params.key?(:end_)
  query_params["non_auto_updated_coverages_only"] = params[:non_auto_updated_coverages_only] if params.key?(:non_auto_updated_coverages_only)
  query_params["sort_direction"] = params[:sort_direction] if params.key?(:sort_direction)
  query_params["limit"] = params[:limit] if params.key?(:limit)
  params = params.except(*query_param_names)

  request = Candid::Internal::JSON::Request.new(
    base_url: request_options[:base_url] || @base_url || @environment&.dig(:pre_encounter),
    method: "GET",
    path: "/coverages/v1/#{params[:id]}/history",
    query: query_params,
    request_options: request_options
  )
  begin
    response = @client.send(request)
  rescue Net::HTTPRequestTimeout
    raise Candid::Errors::TimeoutError
  end
  code = response.code.to_i
  return if code.between?(200, 299)

  error_class = Candid::Errors::ResponseError.subclass_for_code(code)
  raise error_class.new(response.body, code: code)
end

#get_multi(request_options: {}, **params) ⇒ Array[Candid::PreEncounter::Coverages::V1::Types::Coverage]

Returns a list of Coverages based on the search criteria.

Parameters:

  • request_options (Hash) (defaults to: {})
  • params (Hash)

Options Hash (request_options:):

  • :base_url (String)
  • :additional_headers (Hash{String => Object})
  • :additional_query_parameters (Hash{String => Object})
  • :additional_body_parameters (Hash{String => Object})
  • :timeout_in_seconds (Integer)

Options Hash (**params):

  • :patient_id (String, nil)

Returns:

Raises:

  • (error_class) 


234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 234

def get_multi(request_options: {}, **params)
  params = Candid::Internal::Types::Utils.normalize_keys(params)
  query_param_names = %i[patient_id]
  query_params = {}
  query_params["patient_id"] = params[:patient_id] if params.key?(:patient_id)
  params.except(*query_param_names)

  request = Candid::Internal::JSON::Request.new(
    base_url: request_options[:base_url] || @base_url || @environment&.dig(:pre_encounter),
    method: "GET",
    path: "/coverages/v1",
    query: query_params,
    request_options: request_options
  )
  begin
    response = @client.send(request)
  rescue Net::HTTPRequestTimeout
    raise Candid::Errors::TimeoutError
  end
  code = response.code.to_i
  return if code.between?(200, 299)

  error_class = Candid::Errors::ResponseError.subclass_for_code(code)
  raise error_class.new(response.body, code: code)
end

#get_multi_paginated(request_options: {}, **params) ⇒ Candid::PreEncounter::Coverages::V1::Types::CoveragesPage

Returns a page of Coverages based on the search criteria.

Parameters:

  • request_options (Hash) (defaults to: {})
  • params (Hash)

Options Hash (request_options:):

  • :base_url (String)
  • :additional_headers (Hash{String => Object})
  • :additional_query_parameters (Hash{String => Object})
  • :additional_body_parameters (Hash{String => Object})
  • :timeout_in_seconds (Integer)

Options Hash (**params):

  • :patient_id (String, nil)
  • :payer_plan_group_id (String, nil)
  • :page_token (String, nil)
  • :limit (Integer, nil)

Returns:



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 109

def get_multi_paginated(request_options: {}, **params)
  params = Candid::Internal::Types::Utils.normalize_keys(params)
  query_param_names = %i[patient_id payer_plan_group_id page_token limit]
  query_params = {}
  query_params["patient_id"] = params[:patient_id] if params.key?(:patient_id)
  query_params["payer_plan_group_id"] = params[:payer_plan_group_id] if params.key?(:payer_plan_group_id)
  query_params["page_token"] = params[:page_token] if params.key?(:page_token)
  query_params["limit"] = params[:limit] if params.key?(:limit)
  params.except(*query_param_names)

  request = Candid::Internal::JSON::Request.new(
    base_url: request_options[:base_url] || @base_url || @environment&.dig(:pre_encounter),
    method: "GET",
    path: "/coverages/v1/get-multi-paginated",
    query: query_params,
    request_options: request_options
  )
  begin
    response = @client.send(request)
  rescue Net::HTTPRequestTimeout
    raise Candid::Errors::TimeoutError
  end
  code = response.code.to_i
  if code.between?(200, 299)
    Candid::PreEncounter::Coverages::V1::Types::CoveragesPage.load(response.body)
  else
    error_class = Candid::Errors::ResponseError.subclass_for_code(code)
    raise error_class.new(response.body, code: code)
  end
end

#scan(request_options: {}, **params) ⇒ Array[Candid::PreEncounter::Coverages::V1::Types::Coverage]

Scans up to 100 coverage updates. The since query parameter is inclusive, and the result list is ordered by updatedAt ascending.

**Polling Pattern:** To continuously poll for updates without gaps:

  1. Make your initial request with a ‘since` timestamp (e.g., `since=2020-01-01T13:00:00.000Z`)

  2. The API returns up to 100 coverage records, sorted by ‘updated_at` ascending

  3. Find the ‘updated_at` value from the last record in the response

  4. Use that ‘updated_at` value as the `since` parameter in your next request

  5. Repeat steps 2-4 to ingest updates until you receive an empty list

**Important Notes:**

  • The ‘since` parameter is inclusive, so you may receive the last record from the previous batch again (you

can deduplicate by ID and version)

  • All coverage records include ‘updated_at`, `id`, `version`, `deactivated`, and `updating_user` fields for

tracking changes

  • Timestamps have millisecond resolution for precise ordering

Parameters:

  • request_options (Hash) (defaults to: {})
  • params (Hash)

Options Hash (request_options:):

  • :base_url (String)
  • :additional_headers (Hash{String => Object})
  • :additional_query_parameters (Hash{String => Object})
  • :additional_body_parameters (Hash{String => Object})
  • :timeout_in_seconds (Integer)

Options Hash (**params):

  • :since (String)

Returns:

Raises:

  • (error_class) 


288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 288

def scan(request_options: {}, **params)
  params = Candid::Internal::Types::Utils.normalize_keys(params)
  query_param_names = %i[since]
  query_params = {}
  query_params["since"] = params[:since] if params.key?(:since)
  params.except(*query_param_names)

  request = Candid::Internal::JSON::Request.new(
    base_url: request_options[:base_url] || @base_url || @environment&.dig(:pre_encounter),
    method: "GET",
    path: "/coverages/v1/updates/scan",
    query: query_params,
    request_options: request_options
  )
  begin
    response = @client.send(request)
  rescue Net::HTTPRequestTimeout
    raise Candid::Errors::TimeoutError
  end
  code = response.code.to_i
  return if code.between?(200, 299)

  error_class = Candid::Errors::ResponseError.subclass_for_code(code)
  raise error_class.new(response.body, code: code)
end

#update(request_options: {}, **params) ⇒ Candid::PreEncounter::Coverages::V1::Types::Coverage

Updates a Coverage. The path must contain the next version number to prevent race conditions. For example, if the current version of the coverage is n, you will need to send a request to this endpoint with ‘/id/n+1` to update the coverage. Updating historic versions is not supported.

Parameters:

Options Hash (request_options:):

  • :base_url (String)
  • :additional_headers (Hash{String => Object})
  • :additional_query_parameters (Hash{String => Object})
  • :additional_body_parameters (Hash{String => Object})
  • :timeout_in_seconds (Integer)

Options Hash (**params):

Returns:



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/candid/pre_encounter/coverages/v_1/client.rb', line 71

def update(request_options: {}, **params)
  params = Candid::Internal::Types::Utils.normalize_keys(params)
  request = Candid::Internal::JSON::Request.new(
    base_url: request_options[:base_url] || @base_url || @environment&.dig(:pre_encounter),
    method: "PUT",
    path: "/coverages/v1/#{params[:id]}/#{params[:version]}",
    body: Candid::PreEncounter::Coverages::V1::Types::MutableCoverage.new(params).to_h,
    request_options: request_options
  )
  begin
    response = @client.send(request)
  rescue Net::HTTPRequestTimeout
    raise Candid::Errors::TimeoutError
  end
  code = response.code.to_i
  if code.between?(200, 299)
    Candid::PreEncounter::Coverages::V1::Types::Coverage.load(response.body)
  else
    error_class = Candid::Errors::ResponseError.subclass_for_code(code)
    raise error_class.new(response.body, code: code)
  end
end