Module: Canql::Nodes::Anomaly::WithCondition

Defined in:
lib/canql/nodes/anomaly.rb

Instance Method Summary collapse

Instance Method Details

#anomaly_screening_status_type ⇒ Object 



15
16
17
 
# File 'lib/canql/nodes/anomaly.rb', line 15

def anomaly_screening_status_type
  screening_status_type.text_value.strip
end

#anomaly_screening_status_type_filter ⇒ Object 



44
45
46
 
# File 'lib/canql/nodes/anomaly.rb', line 44

def anomaly_screening_status_type_filter
  { Canql::EQUALS => anomaly_screening_status_type }
end

#anomaly_status_type ⇒ Object 



11
12
13
 
# File 'lib/canql/nodes/anomaly.rb', line 11

def anomaly_status_type
  status_type.text_value.strip
end

#anomaly_status_type_filter ⇒ Object 



40
41
42
 
# File 'lib/canql/nodes/anomaly.rb', line 40

def anomaly_status_type_filter
  { Canql::EQUALS => anomaly_status_type }
end

#anomaly_type ⇒ Object 



7
8
9
 
# File 'lib/canql/nodes/anomaly.rb', line 7

def anomaly_type
  natal_period.text_value.strip
end

#anomaly_type_filter ⇒ Object 



36
37
38
 
# File 'lib/canql/nodes/anomaly.rb', line 36

def anomaly_type_filter
  { Canql::EQUALS => anomaly_type }
end

#code_filter ⇒ Object 



74
75
76
77
78
79
80
81
82
83
 
# File 'lib/canql/nodes/anomaly.rb', line 74

def code_filter
  return {} if code_data.text_value.blank?

  code_arrays = { icd_code: [], code_group: [] }
  code_arrays[code_type(code_data.first)] << code_value(code_data.first)
  code_data.rest.elements.each do |code|
    code_arrays[code_type(code)] << code_value(code)
  end
  prepare_code_filters(code_arrays)
end

#code_type(code) ⇒ Object 



48
49
50
51
52
 
# File 'lib/canql/nodes/anomaly.rb', line 48

def code_type(code)
  return :icd_code if code.respond_to?(:to_code) && code.to_code.present?
  return :code_group if code.respond_to?(:to_code_group) && code.to_code_group.present?
  raise 'Unable to find code type'
end

#code_value(code) ⇒ Object 



54
55
56
57
 
# File 'lib/canql/nodes/anomaly.rb', line 54

def code_value(code)
  return code.to_code if :icd_code == code_type(code)
  code.to_code_group
end

#existance_filter ⇒ Object 



32
33
34
 
# File 'lib/canql/nodes/anomaly.rb', line 32

def existance_filter
  { Canql::EQUALS => existance_modifier.text_value.strip != 'no' }
end

#prepare_code_filters(code_array) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/canql/nodes/anomaly.rb', line 59

def prepare_code_filters(code_array)
  code_array[:icd_code].flatten!
  code_array[:icd_code].delete_if(&:blank?)
  code_array[:code_group].flatten!
  code_array[:code_group].delete_if(&:blank?)

  code_filters = {}
  if code_array[:icd_code].any?
    code_filters[:icd_code] = { Canql::BEGINS => code_array[:icd_code] }
  end
  return code_filters if code_array[:code_group].blank?
  code_filters[:code_group] = { Canql::EQUALS => code_array[:code_group] }
  code_filters
end

#to_anomaly ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/canql/nodes/anomaly.rb', line 19

def to_anomaly
  anomaly_hash = { 'exists' => existance_filter }
  anomaly_hash['type'] = anomaly_type_filter if anomaly_type.present?
  anomaly_hash['status'] = anomaly_status_type_filter if anomaly_status_type.present?
  if anomaly_screening_status_type.present?
    anomaly_hash['screening_status'] = anomaly_screening_status_type_filter
  end
  anomaly_hash['icd_codes'] = code_filter[:icd_code] if code_filter[:icd_code].present?
  return anomaly_hash if code_filter[:code_group].blank?
  anomaly_hash['code_groups'] = code_filter[:code_group]
  anomaly_hash
end