health-data-standards 1.0.1 → 2.0.0

data/lib/health-data-standards/import/ccda/medical_equipment_importer.rb

@@ -4,10 +4,9 @@ module HealthDataStandards
       class MedicalEquipmentImporter < C32::MedicalEquipmentImporter
         
         def initialize
-          @entry_xpath = "//cda:section[cda:templateId/@root='2.16.840.1.113883.10.20.22.4.50']/cda:entry/cda:supply"
+          @entry_xpath = "//cda:section[cda:templateId/@root='2.16.840.1.113883.10.20.22.2.23']/cda:entry/cda:supply"
           @code_xpath = "./cda:participant/cda:participantRole/cda:playingDevice/cda:code"
           @description_xpath = "./cda:code/cda:originalText/cda:reference[@value] | ./cda:text/cda:reference[@value]"
-
         end
   
       end

data/lib/health-data-standards/import/ccda/result_importer.rb

@@ -6,6 +6,7 @@ module HealthDataStandards
           @entry_xpath = "//cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.22.4.2']"
           @code_xpath = "./cda:code"
           @description_xpath = "./cda:code/cda:originalText/cda:reference[@value] | ./cda:text/cda:reference[@value] "
+          @check_for_usable = true  
         end
       end
     end

data/lib/health-data-standards/import/ccr/provider_importer.rb

@@ -33,7 +33,6 @@ module HealthDataStandards
             provider[:npi] = npi if Provider.valid_npi?(npi)
           end
           
-          # binding.pry
           find_or_create_provider(provider)
         end
         

data/lib/health-data-standards/import/green_c32/immunization_importer.rb

@@ -13,7 +13,7 @@ module HealthDataStandards
           extract_code(immunization_element, immunization, "./gc32:refusalReason")
           series_number = extract_node_text(immunization_element.at_xpath("./gc32:seriesNumber"))
           immunization.series_number = series_number.to_i if series_number
-          immunization.refusalInd = extract_node_attribute(immunization_element, :refused, true)
+          immunization.refusal_ind = extract_node_attribute(immunization_element, :refused, true)
           immunization
         end
         

data/lib/health-data-standards/import/green_c32/section_importer.rb

@@ -71,7 +71,7 @@ module HealthDataStandards
           
           return unless datetime && datetime['value']
           
-          entry.send("#{attribute}=", Time.parse(datetime['value']).to_i)
+          entry.send("#{attribute}=", Time.parse(datetime['value']).utc.to_i)
         end
         
         def extract_interval(element, entry, element_name="effectiveTime")
@@ -89,11 +89,14 @@ module HealthDataStandards
           
           return {} unless node_value
           
-          {'scalar' => node_value, "unit" => node_units}
+          {"scalar" => node_value, "unit" => node_units}
         end
         
         def extract_value(element, entry)
-          entry.value = extract_quantity(element, @value)
+          pq = extract_quantity(element, @value)
+          if pq.present?
+            entry.values << PhysicalQuantityResultValue.new(pq)
+          end
         end
         
         def extract_entry(element, entry)
@@ -142,8 +145,7 @@ module HealthDataStandards
         def extract_free_text(element, entry, free_text_element="freeText")
           entry.free_text = extract_node_text(element.at_xpath("./gc32:#{free_text_element}"))
         end
-        
-        
+                
         private
         
         def build_code(code_element)

data/lib/health-data-standards/import/provider_import_utils.rb

@@ -6,7 +6,7 @@ module ProviderImportUtils
   end
   
   def find_or_create_provider(provider_hash)
-    provider = Provider.first(conditions: {npi: provider_hash[:npi]}) if provider_hash[:npi] && !provider_hash[:npi].empty?
+    provider = Provider.where(npi: provider_hash[:npi]).first if provider_hash[:npi] && !provider_hash[:npi].empty?
     provider ||= Provider.create(provider_hash)
   end
 

data/lib/health-data-standards/models/coded_result_value.rb

@@ -0,0 +1,3 @@
+class CodedResultValue < ResultValue
+  include ThingWithCodes
+end

data/lib/health-data-standards/models/condition.rb

@@ -1,9 +1,11 @@
 class Condition < Entry
-  field :type,          type: String
-  field :causeOfDeath,  type: Boolean
-  field :priority,      type: Integer
-  field :name,          type: String
-  field :ordinality,    type: String
+  field :type,                type: String
+  field :causeOfDeath,        type: Boolean
+  field :priority,            type: Integer
+  field :name,                type: String
+  field :ordinality,          type: String
+  field :ordinality_code,     type: Hash
+  field :severity,            type: Hash # Currently unsupported by any importers
 
   embeds_many :treating_provider,  class_name: "Provider"
   

data/lib/health-data-standards/models/encounter.rb

@@ -1,8 +1,11 @@
 class Encounter < Entry
+
   field :admitType, type: Hash
   field :dischargeDisposition, type: Hash
-  
-  embeds_one :facility, class_name: "Organization"
+  field :admit_time, type: Integer
+  field :discharge_time, type: Integer
+
+  embeds_one :facility
   embeds_one :reason, class_name: "Entry"
 
   belongs_to :performer, class_name: "Provider"

data/lib/health-data-standards/models/entry.rb

@@ -1,61 +1,35 @@
 class Entry
 
   include Mongoid::Document
+  include ThingWithCodes
 
   # embedded_in :entry_list, polymorphic: true
   
   embedded_in :record
   
+  embeds_many :values, class_name: "ResultValue"
+  
   field :description, type: String
   field :specifics, type: String
   field :time, type: Integer
   field :start_time, type: Integer
   field :end_time, type: Integer
-  field :status, type: String
-  field :codes, type: Hash, default: {}
-  field :value, type: Hash, default: {}
+  field :status_code, type: Hash
   field :free_text, type: String
   field :mood_code, type: String, default: "EVN"
+  field :negationInd, type: Boolean
+  field :negationReason, type: Hash
+  field :oid, type: String
+  
+  alias :negation_ind :negationInd
+  alias :negation_ind= :negationInd=
+  alias :negation_reason :negationReason
+  alias :negation_reason= :negationReason=
   
   attr_protected :version
   attr_protected :_id
   attr_protected :created_at
   attr_protected :updated_at
-
-  def single_code_value?
-    codes.size == 1 && codes.first[1].size == 1
-  end
-
-  def codes_to_s
-    codes.map {|code_set, codes| "#{code_set}: #{codes.join(', ')}"}.join(' ')
-  end
-  
-  # Will return a single code and code set if one exists in the code sets that are
-  # passed in. Returns a hash with a key of code and code_set if found, nil otherwise
-  def preferred_code(preferred_code_sets, codes_attribute=:codes)
-    codes_value = send(codes_attribute)
-    matching_code_sets = preferred_code_sets & codes_value.keys
-    if matching_code_sets.present?
-      code_set = matching_code_sets.first
-      {'code' => codes_value[code_set].first, 'code_set' => code_set}
-    else
-      nil
-    end
-  end
-  
-  # Will return an Array of code and code_set hashes for all codes for this entry
-  # except for the preferred_code. It is intended that these codes would be used in
-  # the translation elements as childern of a CDA code element
-  def translation_codes(preferred_code_sets)
-    tx_codes = []
-    codes.each_pair do |code_set, code_list|
-      code_list.each do |code|
-        tx_codes << {'code' => code, 'code_set' => code_set}
-      end
-    end
-    
-    tx_codes - [preferred_code(preferred_code_sets)]
-  end
   
   def times_to_s
     if start_time.present? || end_time.present?
@@ -67,24 +41,38 @@ class Entry
     end
   end
   
-  # def to_effective_time(xml)
-  #   if time.present?
-  #     xml.effectiveTime("value" => Time.at(time).utc.to_formatted_s(:number))
-  #   else
-  #     xml.effectiveTime do
-  #       if start_time.present?
-  #         xml.low("value" => Time.at(start_time).utc.to_formatted_s(:number))
-  #       else
-  #         xml.low("nullFlavor" => "UNK")
-  #       end
-  #       if end_time.present?
-  #         xml.high("value" => Time.at(end_time).utc.to_formatted_s(:number))          
-  #       else
-  #         xml.high("nullFlavor" => "UNK")          
-  #       end
-  #     end
-  #   end
-  # end
+  # Entry previously had a status field that dropped the code set and converted
+  # the status to a String. Entry now preserves the original code and code set.
+  # This method is here to maintain backwards compatibility.
+  def status
+    if status_code.present?
+      if status_code['HL7 ActStatus']
+        status_code['HL7 ActStatus'].first()
+      elsif status_code['SNOMED-CT']
+        case status_code['SNOMED-CT'].first()
+        when '55561003'
+          'active'
+        when '73425007'
+          'inactive'
+        when '413322009'      
+          'resolved'
+        end
+      end
+    end
+  end
+  
+  def status=(status_text)
+    case status_text.to_s # makes sure that any Symbols passed in are stringified
+    when 'active'
+      self.status_code = {'SNOMED-CT' => ['55561003'], 'HL7 ActStatus' => ['active']}
+    when 'inactive'
+      self.status_code = {'SNOMED-CT' => ['73425007']}
+    when 'resolved'
+      self.status_code = {'SNOMED-CT' => ['413322009']}
+    when 'completed'
+      self.status_code = {'HL7 ActStatus' => ['completed']}
+    end
+  end
   
   def self.from_event_hash(event)
     entry = Entry.new
@@ -107,20 +95,12 @@ class Entry
     entry
   end
 
-  # Add a code into the Entry
-  # @param [String] code the code to add
-  # @param [String] code_system the code system that the code belongs to
-  def add_code(code, code_system)
-    self.codes[code_system] ||= []
-    self.codes[code_system] << code
-  end
-
   # Sets the value for the entry
   # @param [String] scalar the value
   # @param [String] units the units of the scalar value
   def set_value(scalar, units=nil)
-    self.value[:scalar] = scalar
-    self.value[:units] = units
+    pq_value = PhysicalQuantityResultValue.new(scalar: scalar, units: units)
+    self.values << pq_value
   end
 
   # Checks if a code is in the list of possible codes
@@ -186,8 +166,8 @@ class Entry
   def to_hash
     entry_hash = {}
     entry_hash['codes'] = codes
-    unless value.empty?
-      entry_hash['value'] = value
+    unless values.empty?
+      entry_hash['value'] = values
     end
     
     if is_date_range?

data/lib/health-data-standards/models/facility.rb

@@ -0,0 +1,9 @@
+class Facility
+  include Mongoid::Document
+  
+  field :name, type: String
+  field :code, type: Hash
+  
+  embeds_many :addresses, as: :locatable
+  embeds_many :telecoms, as: :contactable
+end

data/lib/health-data-standards/models/functional_status.rb

@@ -0,0 +1,25 @@
+# This class can be used to represnt a functional status for a patient. Currently,
+# it is not a very close representation of functional status as it is represented
+# in the HL7 CCD, HITSP C32 or Consolidated CDA.
+#
+# In the previously mentioned specifications, functional status may represented
+# using either a condition or result. Having "mixed" types of entries in a section
+# is currently not well supported in the existing Record class
+# 
+# Additionally, there is a mismatch between the data needed to calculate Stage 2
+# Meaningful Use Quailty Measures and the data contained in patient summary
+# standards. The CQMs are checking to see if a functional status represented by
+# a result was patient supplied. Right now, results do not have a source, and
+# even if we were to use Provider as a source, it would need to be extended
+# to support patients.
+#
+# To avoid this, the patient sumamry style functional status has been "flattened"
+# into this class. This model supports the information needed to calculate
+# Stage 2 MU CQMs. If importers are created from C32 or CCDA, the information
+# can be stored here, but it will be a lossy transformation.
+class FunctionalStatus < Entry
+  # Either "condition" or "result"
+  field :type, type: String
+  # A coded value. Like a code for patient supplied.
+  field :source, type: Hash
+end

data/lib/health-data-standards/models/immunization.rb

@@ -1,16 +1,14 @@
 class Immunization < Entry
-  field :refusalInd, type: Boolean
-  field :refusalReason, type: Hash
   field :seriesNumber, type: Integer
   
   belongs_to :performer, class_name: "Provider"
   
   embeds_one :medication_product
   
-  alias :refusal_ind :refusalInd
-  alias :refusal_ind= :refusalInd=
-  alias :refusal_reason :refusalReason
-  alias :refusal_reason= :refusalReason=
+  alias :refusal_ind :negationInd
+  alias :refusal_ind= :negationInd=
+  alias :refusal_reason :negationReason
+  alias :refusal_reason= :negationReason=
   alias :series_number :seriesNumber
   alias :series_number= :seriesNumber=
 end

data/lib/health-data-standards/models/medication.rb

@@ -18,6 +18,10 @@ class Medication < Entry
   field :deliveryMethod, type: Hash
   field :patientInstructions, type: String
   field :doseIndicator, type: String
+
+  # There are currently no importers that support this field
+  # It is expected to be a scalar and value, such as 7 days
+  field :cumulativeMedicationDuration, type: Hash
   
   alias :administration_timing :administrationTiming
   alias :administration_timing= :administrationTiming=
@@ -41,4 +45,6 @@ class Medication < Entry
   alias :patient_instructions= :patientInstructions=
   alias :dose_indicator :doseIndicator
   alias :dose_indicator= :doseIndicator=
+  alias :cumulative_medication_duration :cumulativeMedicationDuration
+  alias :cumulative_medication_duration= :cumulativeMedicationDuration=
 end

data/lib/health-data-standards/models/physical_quantity_result_value.rb

@@ -0,0 +1,4 @@
+class PhysicalQuantityResultValue < ResultValue
+  field :scalar
+  field :units, type: String
+end

data/lib/health-data-standards/models/record.rb

@@ -12,9 +12,13 @@ class Record
   field :race, type: Hash
   field :ethnicity, type: Hash
   field :languages, type: Array
-  field :test_id, type: BSON::ObjectId
+  field :test_id, type: Moped::BSON::ObjectId
   field :marital_status, type: Hash # TODO
   field :medical_record_number, type: String
+  field :expired, type: Boolean
+  field :clinicalTrialParticipant, type: Boolean   # Currently not implemented in the C32 importer
+                                                   # because it cannot be easily represented in a
+                                                   # HITSP C32
 
   embeds_many :allergies
   embeds_many :care_goals, class_name: "Entry" # This can be any number of different entry types
@@ -30,9 +34,11 @@ class Record
   embeds_many :support
   embeds_many :advance_directives, class_name: "Entry"
   embeds_many :insurance_providers
+  embeds_many :functional_statuses
 
   Sections = [:allergies, :care_goals, :conditions, :encounters, :immunizations, :medical_equipment,
-   :medications, :procedures, :results, :social_history, :vital_signs, :support, :advanced_directives]
+   :medications, :procedures, :results, :social_history, :vital_signs, :support, :advanced_directives,
+   :functional_statuses]
 
   embeds_many :provider_performances
   
@@ -47,6 +53,9 @@ class Record
     Time.at(birthdate) < Time.now.years_ago(18)
   end
   
+  alias :clinical_trial_participant :clinicalTrialParticipant
+  alias :clinical_trial_participant= :clinicalTrialParticipant=
+  
   private 
   
   def self.provider_queries(provider_id, effective_date)

data/lib/health-data-standards/models/result_value.rb

@@ -0,0 +1,4 @@
+class ResultValue
+  include Mongoid::Document
+  embedded_in :entry
+end

data/lib/health-data-standards/models/thing_with_codes.rb

@@ -0,0 +1,52 @@
+module ThingWithCodes
+  def self.included(receiver)
+    receiver.field :codes, type: Hash, default: {}
+  end
+  
+  def single_code_value?
+    codes.size == 1 && codes.first[1].size == 1
+  end
+
+  def codes_to_s
+    ThingWithCodes.convert_codes_to_s(codes)
+  end
+  
+  def self.convert_codes_to_s(codes)
+    codes.map {|code_set, codes| "#{code_set}: #{codes.join(', ')}"}.join(' ')
+  end
+
+  # Will return a single code and code set if one exists in the code sets that are
+  # passed in. Returns a hash with a key of code and code_set if found, nil otherwise
+  def preferred_code(preferred_code_sets, codes_attribute=:codes)
+    codes_value = send(codes_attribute)
+    matching_code_sets = preferred_code_sets & codes_value.keys
+    if matching_code_sets.present?
+      code_set = matching_code_sets.first
+      {'code' => codes_value[code_set].first, 'code_set' => code_set}
+    else
+      nil
+    end
+  end
+
+  # Will return an Array of code and code_set hashes for all codes for this entry
+  # except for the preferred_code. It is intended that these codes would be used in
+  # the translation elements as childern of a CDA code element
+  def translation_codes(preferred_code_sets)
+    tx_codes = []
+    codes.each_pair do |code_set, code_list|
+      code_list.each do |code|
+        tx_codes << {'code' => code, 'code_set' => code_set}
+      end
+    end
+
+    tx_codes - [preferred_code(preferred_code_sets)]
+  end
+
+  # Add a code into the Entry
+  # @param [String] code the code to add
+  # @param [String] code_system the code system that the code belongs to
+  def add_code(code, code_system)
+    self.codes[code_system] ||= []
+    self.codes[code_system] << code
+  end
+end