Module: DaVinciCRDTestKit::MockServiceResponse

Included in:
HookRequestEndpoint
Defined in:
lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb

Overview

Serve responses to CRD hook invocations

Instance Method Summary collapse

Instance Method Details

#add_basic_cards(cards) ⇒ Object 



257
258
259
260
261
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 257

def add_basic_cards(cards)
  cards.append(create_form_completion_card) if selected_response_types.include?('request_form_completion')
  cards.append(load_json_file('launch_smart_app.json')) if selected_response_types.include?('launch_smart_app')
  cards.append(load_json_file('external_reference.json')) if selected_response_types.include?('external_reference')
end

#add_coverage_cards(cards) ⇒ Object 



263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 263

def add_coverage_cards(cards)
  return unless add_coverage_cards?

  system_actions = []
  if patient_coverage.present?
    if selected_response_types.include?('coverage_information') || coverage_information_required?
      system_actions = create_coverage_extension_system_actions(patient_coverage.id)
    end

    if selected_response_types.include?('create_update_coverage_info')
      coverage_card = create_or_update_coverage(patient_coverage)
      cards.append(coverage_card) if coverage_card.present?
    end
  end
  system_actions
end

#add_coverage_cards? ⇒ Boolean

Returns:

  • (Boolean) 


223
224
225
226
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 223

def add_coverage_cards?
  ['coverage_information', 'create_update_coverage_info'].any? { |x| selected_response_types.include?(x) } ||
    coverage_information_required?
end

#add_coverage_extension(resource, coverage_id) ⇒ Object 



392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 392

def add_coverage_extension(resource, coverage_id)
  resource.extension = [
    FHIR::Extension.new(
      url: 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information',
      extension: [
        FHIR::Extension.new(
          url: 'coverage',
          valueReference: FHIR::Reference.new(
            reference: "Coverage/#{coverage_id}"
          )
        ),
        FHIR::Extension.new(
          url: 'covered',
          valueCode: 'covered'
        ),
        FHIR::Extension.new(
          url: 'pa-needed',
          valueCode: 'no-auth'
        ),
        FHIR::Extension.new(
          url: 'date',
          valueDate: current_time.strftime('%Y-%m-%d')
        ),
        FHIR::Extension.new(
          url: 'coverage-assertion-id',
          valueString: SecureRandom.hex(32)
        )
      ]
    )
  ]
end

#add_order_hook_cards(cards) ⇒ Object 



249
250
251
252
253
254
255
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 249

def add_order_hook_cards(cards)
  cards.append(create_companions_prerequisites_card) if selected_response_types.include?('companions_prerequisites')

  return unless selected_response_types.include?('propose_alternate_request')

  cards.append(create_alternate_request_card)
end

#build_mock_hook_response ⇒ Object 



4
5
6
7
8
9
10
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 4

def build_mock_hook_response
  hook_card_response = create_cards_and_system_actions
  update_specific_hook_card_info(hook_card_response)
  create_warning_messages(hook_card_response)

  hook_card_response
end

#connection ⇒ Object 



160
161
162
163
164
165
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 160

def connection
  @connection ||= Faraday.new do |f|
    f.request :url_encoded
    f.use FaradayMiddleware::FollowRedirects
  end
end

#context ⇒ Object 



39
40
41
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 39

def context
  request_body['context']
end

#coverage_information_required? ⇒ Boolean

Returns:

  • (Boolean) 


69
70
71
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 69

def coverage_information_required?
  coverage_information_required_hooks.include? requested_hook
end

#coverage_information_required_hooks ⇒ Object 



23
24
25
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 23

def coverage_information_required_hooks
  ['appointment-book', 'order-dispatch', 'order-sign']
end

#create_alternate_request_card ⇒ Object 



519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 519

def create_alternate_request_card
  return if context.nil?

  propose_alternate_request_card = load_json_file('propose_alternate_request.json')

  order_resource = identify_alternate_order_resource
  return if order_resource.nil?

  order_resource_type = order_resource.resourceType
  order_resource_id = order_resource.id

  card_actions = propose_alternate_request_card['suggestions'][0]['actions']
  card_actions.push(
    {
      'type' => 'delete',
      'description' => 'Remove current order until health assessment has been done',
      'resourceId' => "#{order_resource_type}/#{order_resource_id}"
    },
    {
      'type' => 'create',
      'description' => 'Order for patient health assessment',
      'resource' => order_resource
    }
  )
  propose_alternate_request_card
end

#create_card_response(hook_card_response) ⇒ Object 



111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 111

def create_card_response(hook_card_response)
  if hook_card_response.nil?
    response.headers.merge!({ 'Access-Control-Allow-Origin' => '*' })
    response.status = 400
    response.body = 'Invalid Request: Incorrect format for hook request body'
  else
    response.body = hook_card_response.to_json
    response.headers.merge!({ 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' })
    response.status = 200
    response.format = :json
  end
end

#create_cards_and_system_actions ⇒ Object 



228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 228

def create_cards_and_system_actions
  return if context.nil?

  cards = []

  add_basic_cards(cards)
  add_order_hook_cards(cards)

  system_actions = add_coverage_cards(cards)

  cards.append(load_json_file('instructions.json')) if selected_response_types.include?('instructions') ||
                                                       (cards.empty? && system_actions.nil?)
  cards_response = { 'cards' => cards }
  cards_response['systemActions'] = system_actions if system_actions.present?
  cards_response
rescue StandardError => e
  Inferno::Application['logger'].error(e.full_message)
  # TODO: - make sure this gets logged
  nil
end

#create_companions_prerequisites_card ⇒ Object 



510
511
512
513
514
515
516
517
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 510

def create_companions_prerequisites_card
  return if context.nil?

  companions_prerequisites_card = load_json_file('companions_prerequisites.json')
  card_service_request = companions_prerequisites_card['suggestions'][0]['actions'][0]['resource']
  update_service_request(card_service_request)
  companions_prerequisites_card
end

#create_coverage_extension_system_actions(coverage_id) ⇒ Object 



280
281
282
283
284
285
286
287
288
289
290
291
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 280

def create_coverage_extension_system_actions(coverage_id)
  fhir_resource =
    if requested_hook == 'order-dispatch' && ig_version == 'v221'
      find_prefetched_order_dispatch_orders
    else
      identify_resources_for_system_actions
    end

  create_system_actions(fhir_resource, coverage_id)
rescue StandardError
  nil
end

#create_coverage_resource(patient_id) ⇒ Object 



424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 424

def create_coverage_resource(patient_id)
  FHIR::Coverage.new(
    id: SecureRandom.uuid,
    status: 'draft',
    beneficiary: FHIR::Reference.new(
      reference: "Patient/#{patient_id}"
    ),
    subscriber: FHIR::Reference.new(
      reference: "Patient/#{patient_id}"
    ),
    relationship: FHIR::CodeableConcept.new(
      coding: [
        FHIR::Coding.new(
          system: 'http://terminology.hl7.org/CodeSystem/subscriber-relationship',
          code: 'self'
        )
      ]
    ),
    payor: FHIR::Reference.new(
      reference: "Patient/#{patient_id}"
    )
  )
end

#create_form_completion_card ⇒ Object 



469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 469

def create_form_completion_card
  return if context.nil?

  request_form_completion_card = load_json_file('request_form_completion.json')
  form_completion_questionnaire_action = request_form_completion_card['suggestions'][0]['actions'].find do |action|
    action['resource']['resourceType'] == 'Questionnaire'
  end
  target_fhir_server = request_body['fhirServer'].present? ? request_body['fhirServer'].chomp('/') : ''
  form_completion_questionnaire_action['extension']['davinci-crd.if-none-exist']
    .gsub!('<target_fhir_server>', target_fhir_server)

  form_completion_task = request_form_completion_card['suggestions'][0]['actions'].find do |action|
    action['resource']['resourceType'] == 'Task'
  end['resource']

  form_completion_task['for']['reference'] = "Patient/#{context['patientId']}"
  form_completion_task['authoredOn'] = current_time.strftime('%Y-%m-%d')
  form_completion_task['input'].delete_at(1) if ig_version == 'v221'
  form_completion_task['id'] = SecureRandom.uuid
  payer_reference = payer_reference_from_coverage
  if payer_reference.present?
    form_completion_task['requester']['reference'] = payer_reference
  else
    form_completion_task.delete('requester')
  end
  request_form_completion_card
end

#create_or_update_coverage(coverage) ⇒ Object 



448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 448

def create_or_update_coverage(coverage)
  return if context.nil?

  if coverage.present?
    action = { 'type' => 'update', 'description' => 'Update current coverage record' }
    coverage.period =
      FHIR::Period.new(
        start: current_time.strftime('%Y-%m-%d'),
        end: (current_time + 1.month).strftime('%Y-%m-%d')
      )
    action['resource'] = coverage
  else
    action = { 'type' => 'create', 'description' => 'Create coverage record' }
    new_coverage = create_coverage_resource(context['patientId'])
    action['resource'] = new_coverage
  end
  coverage_info_card = load_json_file('create_update_coverage_information.json')
  coverage_info_card['suggestions'][0]['actions'] = [action]
  coverage_info_card
end

#create_system_actions(resource, coverage_id) ⇒ Object 



363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 363

def create_system_actions(resource, coverage_id)
  return if resource.nil?

  system_actions = []
  if resource.resourceType == 'Bundle'
    resource.entry.each do |entry|
      entry_resource = entry.resource
      add_coverage_extension(entry_resource, coverage_id)
      system_actions.append(
        {
          'type' => 'update',
          'description' => "Added coverage information to #{entry_resource.resourceType} resource.",
          'resource' => entry_resource
        }
      )
    end
  else
    add_coverage_extension(resource, coverage_id)
    system_actions.append(
      {
        'type' => 'update',
        'description' => "Added coverage information to #{resource.resourceType} resource.",
        'resource' => resource
      }
    )
  end
  system_actions
end

#create_warning_messages(hook_card_response) ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 91

def create_warning_messages(hook_card_response)
  missing_response_types =
    if hook_card_response.nil?
      selected_response_types
    else
      get_missing_response_types(hook_card_response)
    end

  return if missing_response_types.empty?

  missing_response_types = format_missing_response_types(missing_response_types)
  missing_response_types.each do |missing_response_type|
    Inferno::Repositories::Messages.new.create(
      result_id: result.id,
      type: 'warning',
      message: %(Unable to return response type `#{missing_response_type}` for #{requested_hook} hook)
    )
  end
end

#current_time ⇒ Object 



19
20
21
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 19

def current_time
  Time.now.utc
end

#extract_prefetched_coverage(prefetch) ⇒ Object 



201
202
203
204
205
206
207
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 201

def extract_prefetched_coverage(prefetch)
  return nil unless prefetch.present?
  return prefetch['coverage'] if prefetch['coverage'].present?
  return prefetch['cov'] if prefetch['cov'].present?

  nil
end

#find_entry_in_prefetch_bundle(prefetch_value, resource_type, id) ⇒ Object 



354
355
356
357
358
359
360
361
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 354

def find_entry_in_prefetch_bundle(prefetch_value, resource_type, id)
  return unless prefetch_value.is_a?(Hash)

  bundle = FHIR.from_contents(prefetch_value.to_json)
  return unless bundle.is_a?(FHIR::Bundle)

  bundle.entry.find { |e| e.resource.present? && e.resource.resourceType == resource_type && e.resource.id == id }
end

#find_one_prefetched_order_dispatch_order(order_reference) ⇒ Object 



342
343
344
345
346
347
348
349
350
351
352
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 342

def find_one_prefetched_order_dispatch_order(order_reference)
  resource_type, id = order_reference.split('/')
  return unless request_body['prefetch'].present?

  request_body['prefetch'].each_value do |prefetch_value|
    entry = find_entry_in_prefetch_bundle(prefetch_value, resource_type, id)
    return entry if entry.present?
  end

  nil
end

#find_prefetched_order_dispatch_orders ⇒ Object 



325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 325

def find_prefetched_order_dispatch_orders
  orders_bundle = FHIR::Bundle.new

  context['dispatchedOrders']&.each do |order_reference|
    prefetched_entry = find_one_prefetched_order_dispatch_order(order_reference)
    if prefetched_entry.present?
      orders_bundle.entry << prefetched_entry
      next
    end

    read_resource = get_context_resource(order_reference)
    orders_bundle.entry << FHIR::Bundle::Entry.new({ resource: read_resource }) if read_resource.present?
  end

  orders_bundle if orders_bundle.entry.present?
end

#find_prefetched_resource(request_body, key_options) ⇒ Object 



307
308
309
310
311
312
313
314
315
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 307

def find_prefetched_resource(request_body, key_options)
  prefetch = request_body['prefetch']
  return if prefetch.blank?

  found_key = key_options&.find { |key| prefetch[key].present? }
  return unless found_key.present?

  prefetch[found_key]
end

#format_missing_response_types(missing_response_types) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 43

def format_missing_response_types(missing_response_types)
  missing_response_types
    .map do |response_type|
    response_type_string =
      response_type.split('_')
        .map(&:capitalize)
        .join(' ')
        .sub('Smart', 'SMART')
        .sub('Create Update', 'Create/Update')
        .sub('Companions Prerequisites', 'Companions/Prerequisites')
    response_type_string
  end
end

#get_context_resource(update_resource_id) ⇒ Object 



209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 209

def get_context_resource(update_resource_id)
  return unless update_resource_id.present?

  update_resource_id = "#{resource_type_to_update}/#{update_resource_id}" unless update_resource_id.include? '/'
  fhir_server = request_body['fhirServer']
  return if fhir_server.blank?

  access_token = request_body['fhirAuthorization']['access_token'] if request_body['fhirAuthorization']
  make_resource_request(
    "#{fhir_server}/#{update_resource_id}",
    access_token
  )
end

#get_missing_response_types(hook_card_response) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 73

def get_missing_response_types(hook_card_response)
  expected_types = if coverage_information_required?
                     selected_response_types | ['coverage_information']
                   else
                     selected_response_types
                   end

  expected_types
    .select do |response_type|
      response_type = response_type
        .split('_')
        .join(' ')
        .sub('create update', 'create/update')
        .sub('companions prerequisites', 'companions/prerequisites')
      missing_response_type_filter(response_type, hook_card_response)
    end
end

#get_patient_coverage ⇒ Object

rubocop:disable Naming/AccessorMethodName



182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 182

def get_patient_coverage # rubocop:disable Naming/AccessorMethodName
  prefetched_coverage =  extract_prefetched_coverage(request_body['prefetch'])
  if prefetched_coverage.present?
    coverage_or_bundle = FHIR.from_contents(prefetched_coverage.to_json)
    coverage_or_bundle.is_a?(FHIR::Bundle) ? coverage_or_bundle.entry.first&.resource : coverage_or_bundle
  else
    fhir_server = request_body['fhirServer']
    if fhir_server.present?
      access_token = request_body['fhirAuthorization']['access_token'] if request_body['fhirAuthorization']
      patient_id = context['patientId']

      make_resource_request(
        "#{fhir_server}/Coverage?patient=#{patient_id}&status=active",
        access_token
      )
    end
  end
end

#identify_alternate_order_resource ⇒ Object 



546
547
548
549
550
551
552
553
554
555
556
557
558
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 546

def identify_alternate_order_resource
  if requested_hook == 'order-dispatch'
    if ig_version == 'v221'
      find_prefetched_order_dispatch_orders&.entry&.first&.resource
    elsif context['order'].present?
      get_context_resource(context['order'])
    end
  else
    draft_orders = context['draftOrders']['entry']
    draft_order_resource = draft_orders[0]['resource']
    FHIR.from_contents(draft_order_resource.to_json)
  end
end

#identify_resources_for_system_actions ⇒ Object 



293
294
295
296
297
298
299
300
301
302
303
304
305
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 293

def identify_resources_for_system_actions
  update_resource = context[resource_to_update_field_name]
  prefetch_id_options = prefetch_key_options_for_system_actions
  prefetched_resource = find_prefetched_resource(request_body, prefetch_id_options)

  if update_resource.is_a? Hash
    FHIR.from_contents(update_resource.to_json)
  elsif prefetched_resource.present?
    FHIR.from_contents(prefetched_resource.to_json)
  elsif update_resource.present?
    get_context_resource(update_resource)
  end
end

#load_json_file(filename) ⇒ Object 



27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 27

def load_json_file(filename)
  json = JSON.parse(File.read(File.join(__dir__, 'mocked_card_responses', filename)))
  if ig_version == 'v221'
    json['source']['topic']['system'] = 'http://terminology.hl7.org/CodeSystem/cdshooks-card-type'
  end
  return json unless filename == 'launch_smart_app.json'

  json['links'].first['url'] = "#{Inferno::Application['base_url']}/custom/smart/launch"

  json
end

#make_resource_request(uri, access_token) ⇒ Object 



167
168
169
170
171
172
173
174
175
176
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 167

def make_resource_request(uri, access_token)
  response = connection.get(uri, nil, { 'Authorization' => "Bearer #{access_token}" })
  return unless response.status == 200

  resource = FHIR.from_contents(response.body)
  return resource unless resource.resourceType == 'Bundle'
  return if resource.entry.empty?

  resource.entry.first.resource
end

#missing_response_type_filter(response_type, hook_card_response) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 57

def missing_response_type_filter(response_type, hook_card_response)
  if response_type == 'coverage information'
    hook_card_response['systemActions'].nil? ||
      hook_card_response['systemActions'].none? do |card|
        card['description'].include?('coverage information')
      end
  else
    hook_card_response['cards'].present? &&
      hook_card_response['cards'].none? { |card| card['summary'].downcase.include?(response_type) }
  end
end

#patient_coverage ⇒ Object 



178
179
180
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 178

def patient_coverage
  @patient_coverage ||= get_patient_coverage
end

#payer_reference_from_coverage ⇒ Object 



497
498
499
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 497

def payer_reference_from_coverage
  patient_coverage&.payor&.first&.reference
end

#prefetch_key_options_for_system_actions ⇒ Object 



317
318
319
320
321
322
323
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 317

def prefetch_key_options_for_system_actions
  if requested_hook.starts_with?('encounter')
    ['encounter', 'enc'] # handle subset service
  elsif requested_hook == 'order-dispatch'
    ['order'] # v2.2.1 order-dispatch handled elsewhere
  end
end

#resource_to_update_field_name ⇒ Object 



141
142
143
144
145
146
147
148
149
150
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 141

def resource_to_update_field_name
  {
    'appointment-book' => 'appointments',
    'encounter-start' => 'encounterId',
    'encounter-discharge' => 'encounterId',
    'order-dispatch' => 'order',
    'order-select' => 'draftOrders',
    'order-sign' => 'draftOrders'
  }[requested_hook]
end

#resource_type_to_update ⇒ Object 



152
153
154
155
156
157
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 152

def resource_type_to_update
  {
    'encounter-start' => 'Encounter',
    'encounter-discharge' => 'Encounter'
  }[requested_hook]
end

#selected_response_types ⇒ Object 



12
13
14
15
16
17
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 12

def selected_response_types
  @selected_response_types ||=
    JSON.parse(result.input_json)
      .find { |input| input['name'].include?('selected_response_types') }
      &.dig('value') || []
end

#update_one_card_info(card, hook_display) ⇒ Object 



135
136
137
138
139
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 135

def update_one_card_info(card, hook_display)
  card['summary'].prepend("#{hook_display} ")
  card['uuid'] = SecureRandom.uuid
  card['suggestions']&.each { |suggestion| suggestion['uuid'] = SecureRandom.uuid if suggestion['uuid'].present? }
end

#update_service_request(service_request) ⇒ Object 



501
502
503
504
505
506
507
508
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 501

def update_service_request(service_request)
  return if context.nil?

  service_request['subject']['reference'] = "Patient/#{context['patientId']}"
  service_request['requester']['reference'] =
    requested_hook == 'order-dispatch' && ig_version == 'v221' ? context['performer'] : context['userId']
  service_request['authoredOn'] = current_time.strftime('%Y-%m-%d')
end

#update_specific_hook_card_info(card_response) ⇒ Object 



124
125
126
127
128
129
130
131
132
133
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 124

def update_specific_hook_card_info(card_response)
  return if card_response.nil?

  hook_display = requested_hook.split('-').map(&:capitalize).join(' ')
  card_response['cards']&.tap(&:compact!)&.each do |card|
    update_one_card_info(card, hook_display)
  end
  card_response['systemActions']&.compact!
  card_response
end