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 



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

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 



255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 255

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) 


215
216
217
218
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 215

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 



373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 373

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 



241
242
243
244
245
246
247
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 241

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

#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 



500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 500

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 



220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 220

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 



491
492
493
494
495
496
497
498
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 491

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 



272
273
274
275
276
277
278
279
280
281
282
283
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 272

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 



405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 405

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 



450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 450

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 



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

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 



344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 344

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 



193
194
195
196
197
198
199
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 193

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 



335
336
337
338
339
340
341
342
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 335

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 



323
324
325
326
327
328
329
330
331
332
333
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 323

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 



306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 306

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

#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 



201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 201

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



174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 174

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 



527
528
529
530
531
532
533
534
535
536
537
538
539
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 527

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 



285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 285

def identify_resources_for_system_actions
  update_resource = context[resource_to_update_field_name]
  prefetch_id = prefetch_key_for_system_actions

  if update_resource.is_a? Hash
    FHIR.from_contents(update_resource.to_json)
  elsif prefetch_id.present? && request_body['prefetch'] && request_body['prefetch'][prefetch_id]
    FHIR.from_contents(request_body['prefetch'][prefetch_id].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 



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

def make_resource_request(uri, access_token)
  response = Faraday.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 



170
171
172
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 170

def patient_coverage
  @patient_coverage ||= get_patient_coverage
end

#payer_reference_from_coverage ⇒ Object 



478
479
480
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 478

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

#prefetch_key_for_system_actions ⇒ Object 



298
299
300
301
302
303
304
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 298

def prefetch_key_for_system_actions
  if requested_hook.starts_with?('encounter')
    'encounter'
  elsif requested_hook == 'order-dispatch'
    'order'
  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 



482
483
484
485
486
487
488
489
 
# File 'lib/davinci_crd_test_kit/client/endpoints/mock_service_response.rb', line 482

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