health-data-standards 3.5.3 → 3.6.1

data/lib/health-data-standards/export/green_c32/record.rb

@@ -1,18 +0,0 @@
-module HealthDataStandards
-  module Export
-    module GreenC32
-      class Record
-        def initialize
-          template_helper = TemplateHelper.new('gc32', 'gc32')
-          @rendering_context = RenderingContext.new
-          @rendering_context.template_helper = template_helper
-          @rendering_context.extensions = [HealthDataStandards::Export::Helper::GC32ViewHelper]
-        end
-
-        def export(patient)
-          @rendering_context.render(:template => 'record', :locals => {:record => patient})
-        end
-      end
-    end
-  end
-end

data/lib/health-data-standards/export/helper/gc32_view_helper.rb

@@ -1,39 +0,0 @@
-module HealthDataStandards
-  module Export
-    module Helper
-      module GC32ViewHelper
-        def gc32_code_display(entry, options={})
-          code_display(entry, options.merge("exclude_null_flavor" => true))
-        end
-        
-        def gc32_effective_time(entry)
-          if entry.time
-            "<effectiveTime value=\"#{Time.at(entry.time).xmlschema}\" />"
-          elsif entry.start_time || entry.end_time
-            gc32_interval(entry, "effectiveTime", :start_time, :end_time)
-          else
-            "<effectiveTime />"
-          end
-        end
-        
-        def gc32_interval(entry, tag_name, start_attribute, end_attribute)
-          time = "<#{tag_name}>"
-          time += "<start value=\"#{Time.at(entry.send(start_attribute)).xmlschema}\" />"  if entry.send(start_attribute)
-          time += "<end value=\"#{Time.at(entry.send(end_attribute)).xmlschema}\" />" if entry.send(end_attribute)
-          time += "</#{tag_name}>"
-        end
-
-        def quantity_display(value, tag_name="value")
-          return unless value
-          if value.respond_to?(:scalar)
-            "<#{tag_name} amount=\"#{value.scalar}\" unit=\"#{value.units}\" />"
-          elsif value['scalar'].present?
-            "<#{tag_name} amount=\"#{value['scalar']}\" unit=\"#{value['units']}\" />"  
-          else
-            "<#{tag_name} amount=\"#{value['value']}\" unit=\"#{value['unit']}\" />"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,238 +0,0 @@
-require "time"
-
-module HealthDataStandards
-  module Import
-    module CCR
-    # This class is the central location for taking an ASTM CCR XML document and converting it
-    # into the processed form we store in MongoDB. The class does this by running each measure
-    # independently on the XML document
-    #
-    # This class is a Singleton. It should be accessed by calling PatientImporter.instance
-      class PatientImporter
-
-        include Singleton
-        
-        Gender = {"male" => "M", "female" => "F"}
-        
-        # Creates a new PatientImporter with the following XPath expressions used to find content in 
-        # an ASTM CCR
-        #
-        # Encounter entries
-        #    //ccr:Encounters/ccr:Encounter
-        # Procedure entries
-        #    //ccr:Procedures/ccr:Procedure
-        #
-        # Result entries - 
-        #    //ccr:Results/ccr:Result
-        #
-        # Vital sign entries
-        #    //ccr:VitalSigns/ccr:Result
-        #
-        # Medication entries
-        #    //ccr:Medications/ccr:Medication
-        #
-        # Codes for medications are found in the Product sections
-        #    ./ccr:Product
-        #
-        # Condition entries
-        #    //ccr:Problems/ccr:Problem
-        #
-        # Social History entries 
-        #    //ccr:SocialHistory/ccr:SocialHistoryElement
-        #
-        # Care Goal entries
-        #    //ccr:Goals/ccr:Goal
-        #
-        # Allergy entries
-        #    //ccr:Alerts/ccr:Alert
-        #
-        # Immunization entries
-        #    //ccr:Immunizations/ccr:Immunization
-        #
-        # Codes for immunizations are found in the substanceAdministration with the following relative XPath
-        #    ./ccr:Product
-      
-        def initialize (check_usable = true)
-          @measure_importers = {}
-          @section_importers = {}
-          @section_importers[:encounters] = SimpleImporter.new("//ccr:Encounters/ccr:Encounter",:encounters)
-          @section_importers[:procedures] = SimpleImporter.new("//ccr:Procedures/ccr:Procedure",:procedures)
-          @section_importers[:results] = ResultImporter.new("//ccr:Results/ccr:Result",:results)
-          @section_importers[:vital_signs] = ResultImporter.new("//ccr:VitalSigns/ccr:Result",:vital_signs)
-          @section_importers[:medications] = ProductImporter.new("//ccr:Medications/ccr:Medication", :medications)
-          @section_importers[:conditions] = SimpleImporter.new("//ccr:Problems/ccr:Problem",:conditions)
-          @section_importers[:social_history] = SimpleImporter.new("//ccr:SocialHistory/ccr:SocialHistoryElement", :social_history)
-          @section_importers[:care_goals] = SimpleImporter.new("//ccr:Goals/ccr:Goal",:care_goals)
-          @section_importers[:medical_equipment] = ProductImporter.new("//ccr:Equipment/ccr:EquipmentElement",:medical_equipment)
-          @section_importers[:allergies] = SimpleImporter.new("//ccr:Alerts/ccr:Alert",:allergies)
-          @section_importers[:immunizations] = ProductImporter.new("//ccr:Immunizations/ccr:Immunization",:immunizations)
-        end
-
- 
-        # @param [boolean] value for check_usable_entries...importer uses true, stats uses false 
-        def check_usable(check_usable_entries)
-          @section_importers.each_pair do |section, importer|
-            importer.check_for_usable = check_usable_entries
-          end
-        end
-
-        # Parses a ASTM CCR document and returns a Hash of of the patient.
-        #
-        # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
-        #        will have the "ccr" namespace registered to ""urn:astm-org:CCR""
-        # @return [Hash] a representation of the patient that can be inserted into MongoDB
-        def parse_ccr(doc, patient_id_xpath="//ccr:ContinuityOfCareRecord/ccr:Patient/ccr:ActorID")
-          ccr_patient = {}
-          entries = create_hash(doc)
-          get_demographics(ccr_patient, doc, patient_id_xpath)
-          process_events(ccr_patient, entries)
-          Record.new(ccr_patient)
-        end
-        # 
-        # # Parses a patient hash containing demographic and event information
-        # #
-        # # @param [Hash] patient_hash patient data
-        # # @return [Hash] a representation of the patient that can be inserted into MongoDB
-        # def parse_hash(patient_hash)
-        #   patient_record = {}
-        #   patient_record['first'] = patient_hash['first']
-        #   patient_record['patient_id'] = patient_hash['patient_id']
-        #   patient_record['last'] = patient_hash['last']
-        #   patient_record['gender'] = patient_hash['gender']
-        #   patient_record['patient_id'] = patient_hash['patient_id']
-        #   patient_record['birthdate'] = patient_hash['birthdate']
-        #   patient_record['race'] = patient_hash['race']
-        #   patient_record['ethnicity'] = patient_hash['ethnicity']
-        #   patient_record['languages'] = patient_hash['languages']
-        #   patient_record['addresses'] = patient_hash['addresses']
-        #   event_hash = {}
-        #   patient_hash['events'].each do |key, value|
-        #     event_hash[key.intern] = parse_events(value)
-        #   end
-        #   process_events(patient_record, event_hash)
-        # end
-
-        # Adds the entries and denormalized measure information to the patient_record.
-        # Each Entry will be converted to a Hash and stored in an Array under the appropriate
-        # section key, such as medications. Measure information is listed under the measures
-        # key which has a Hash value. The Hash has the measure id as a key, and the denormalized
-        # measure information as a value
-        #
-        # @param patient_record - Hash with basic patient demographic information
-        # @entries - Hash of entries with section names a keys and an Array of Entry values
-        def process_events(patient_record, entries)
-          patient_record['measures'] = {}
-          @measure_importers.each_pair do |measure_id, importer|
-            patient_record['measures'][measure_id] = importer.parse(entries)
-          end
-
-
-          entries.each_pair do |key, value|
-            patient_record[key] = value.map do |e|
-              if e.usable?
-                e.to_hash
-              else
-                nil
-              end
-            end.compact
-          end
-          patient_record
-        end
-
-        # # Parses a list of event hashes into an array of Entry objects
-        # #
-        # # @param [Array] event_list list of event hashes
-        # # @return [Array] array of Entry objects
-        # def parse_events(event_list)
-        #   event_list.collect do |event|
-        #     if event.class==String.class
-        #       # skip String elements in the event list, patient randomization templates
-        #       # introduce String elements to simplify tailing-comma handling when generating
-        #       # JSON using ERb
-        #       nil
-        #     else
-        #       QME::Importer::Entry.from_event_hash(event)
-        #     end
-        #   end.compact
-        # end
-
-        # Adds a measure to run on a CCR that is passed in
-        #
-        # @param [MeasureBase] measure an Class that can extract information from a CCR that is necessary
-        #        to calculate the measure
-        def add_measure(measure_id, importer)
-          @measure_importers[measure_id] = importer
-        end
-
-        # Create a simple representation of the patient from an ASTM CCR
-        #
-        # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
-        #        will have the "ccr" namespace registered to ""urn:astm-org:CCR""
-        # @return [Hash] a represnetation of the patient with symbols as keys for each section
-        def create_hash(doc, check_usable_entries = false)
-          ccr_patient = {}
-          @section_importers.each_pair do |section, importer|
-            importer.check_for_usable = check_usable_entries
-            ccr_patient[section] = importer.create_entries(doc)
-          end
-          ccr_patient
-        end
-
-        # Inspects a CCR document and populates the patient Hash with first name, last name
-        # birth date and gender.
-        #
-        # @param [Hash] patient A hash that is used to represent the patient
-        # @param [Nokogiri::XML::Node] doc The CCR document parsed by Nokogiri
-        def get_demographics(patient, doc, patient_id_xpath)
-          patientActorID = doc.at_xpath("//ccr:ContinuityOfCareRecord/ccr:Patient/ccr:ActorID").content
-          patientActor = doc.at_xpath("//ccr:ContinuityOfCareRecord/ccr:Actors/ccr:Actor[ccr:ActorObjectID = \"#{patientActorID}\"]")
-          patientID = patientActor.at_xpath(patient_id_xpath).try(:content)
-          patientID ||= patientActorID
-          
-          name_element = patientActor.at_xpath('./ccr:Person/ccr:Name')
-          
-          if name_element
-            if name_element.at_xpath("./ccr:CurrentName")
-              patient['first'] = name_element.at_xpath('./ccr:CurrentName/ccr:Given').try(:content)
-              patient['last'] = name_element.at_xpath('./ccr:CurrentName/ccr:Family').try(:content)
-            elsif name_element.at_xpath("./ccr:DisplayName")
-              # this will not work in all cases, but we're using it as a last resort if no CurrentName is found
-              first, last = name_element.at_xpath("./ccr:DisplayName").content.split(" ")
-              patient['first'] = first.strip
-              patient['last'] = last.strip
-            end
-          end
-              
-          
-          birthdate = patientActor.at_xpath('./ccr:Person//ccr:DateOfBirth/ccr:ExactDateTime | ./ccr:Person//ccr:DateOfBirth/ccr:ApproximateDateTime')
-          patient['birthdate'] = Time.parse(birthdate.content).to_i if birthdate
-          
-          gender_string = patientActor.at_xpath('./ccr:Person/ccr:Gender/ccr:Text').content.downcase
-          patient['gender'] =  Gender[gender_string.downcase]
-          #race_node = doc.at_xpath('/ccr:placeholder')    #how do you find this?
-          race = doc.at_xpath('//ccr:SocialHistory/ccr:SocialHistoryElement[./ccr:Type/ccr:Text = "Race"]/ccr:Description/ccr:Code[./ccr:CodingSystem = "CDC-RE"]/ccr:Value')
-          ethnicity = doc.at_xpath('//ccr:SocialHistory/ccr:SocialHistoryElement[./ccr:Type/ccr:Text = "Ethnicity"]/ccr:Description/ccr:Code[./ccr:CodingSystem = "CDC-RE"]/ccr:Value')
-          
-          if ethnicity
-            patient[:ethnicity] = {"code" => ethnicity.text, "codeSystem" => 'CDC-RE'}
-          end
-         
-          
-          if race
-             patient[:race] = {"code" => race.text, "codeSystem" => 'CDC-RE'}
-          end
-
-         
-         
-          #ethnicity_node = doc.at_xpath()
-          
-
-          # languages = doc.at_xpath()
-          patient['languages'] = nil
- 
-          patient['medical_record_number'] = patientID
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-module HealthDataStandards
-  module Import
-    module CCR
-      class ProductImporter < SectionImporter
-        
-        # Traverses that ASTM CCR document passed in using XPath and creates an Array of Entry
-        # objects based on what it finds                          
-        # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
-        #        will have the "ccr" namespace registered to "urn:astm-org:CCR"
-        #        measure definition
-        # @return [Array] will be a list of Entry objects
-        def create_entries(doc)
-          entry_list = []
-          entry_elements = doc.xpath(@entry_xpath)
-          entry_elements.each do |entry_element|
-            entry = Entry.new
-            product = entry_element.at_xpath("./ccr:Product")
-            process_product(product,entry)
-            extract_dates(entry_element, entry)
-            extract_status(entry_element, entry)  
-            if @check_for_usable
-              entry_list << entry if entry.usable?
-            else
-              entry_list << entry
-            end  
-          end
-          entry_list           
-        end
-        
-        # Add the codes from a <Product> block subsection to an Entry
-        def process_product_codes(node, entry)
-          codes = node.xpath("./ccr:Code")
-          if codes.size > 0
-            found_code = true
-             codes.each do |code|
-              normalize_coding_system(code)
-              codetext = code.at_xpath("./ccr:CodingSystem").content
-              entry.add_code(code.at_xpath("./ccr:Value").content, codetext)
-            end
-          end
-        end
-
-        # Special handling for the medications section
-        def process_product (product, entry)
-          productName = product.at_xpath("./ccr:ProductName")
-          brandName = product.at_xpath("./ccr:BrandName")
-          productNameText = productName.at_xpath("./ccr:Text")
-          brandNameText = brandName.at_xpath("./ccr:Text")  if brandName
-          entry.description = productNameText.content if productNameText
-          process_product_codes(productName, entry) # we throw any codes found within the productName and brandName into the same entry
-          process_product_codes(brandName, entry) if brandName
-        end
-
-
-        def create_product_entries(doc)
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-require "date"
-# require "date/delta"
-
-module HealthDataStandards
-  module Import
-    module CCR
-      class ProviderImporter
-        include Singleton
-        include ProviderImportUtils
-
-        # Extract Healthcare Providers from CCR
-        #
-        # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
-        #        will have the "ccr" namespace registered to "urn:astm-org:CCR"
-        # @return [Array] an array of providers found in the document
-        
-        def create_provider(actor)
-        # Differentiate care providers by content of this field
-          provider = {}
-          if actor.at_xpath('./ccr:Person/ccr:Name/ccr:CurrentName/ccr:Given')
-            provider[:given_name] = extract_data(actor, './ccr:Person/ccr:Name/ccr:CurrentName/ccr:Given')
-            provider[:family_name] = extract_data(actor, './ccr:Person/ccr:Name/ccr:CurrentName/ccr:Family')
-            provider[:specialty] = extract_data(actor, './ccr:Specialty/ccr:Text')
-          end
-          
-          provider[:specialty] = extract_data(actor, './ccr:Specialty/ccr:Text')
-
-          
-          npi_ids = actor.at_xpath("./ccr:IDs[ccr:Type/ccr:Text = \"NPI\"]")
-          if npi_ids
-            npi_id = npi_ids.at_xpath("./ccr:ID")
-            npi = npi_id.content
-            provider[:npi] = npi if Provider.valid_npi?(npi)
-          end
-          
-          find_or_create_provider(provider)
-        end
-        
-        
-        def extract_providers(doc)
-
-          # Providers are identified as the 'Source' for entries in the CCR.   Sources can also include the patient, relatives, insurance companies, etc
-          provider_elements = doc.xpath("//ccr:ContinuityOfCareRecord/ccr:Actors/ccr:Actor[ccr:IDs/ccr:Type/ccr:Text=\"NPI\"]")
-          provider_elements.map { |pv| ProviderPerformance.new(provider: create_provider(pv)) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-module HealthDataStandards
-  module Import
-    module CCR
-      class ResultImporter < SectionImporter
-        
-        # Traverses that ASTM CCR document passed in using XPath and creates an Array of Entry
-        # objects based on what it finds                          
-        # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
-        #        will have the "ccr" namespace registered to "urn:astm-org:CCR"
-        #        measure definition
-        # @return [Array] will be a list of Entry objects
-        def create_entries(doc)
-          entry_list = []
-          entry_elements = doc.xpath(@entry_xpath)
-          entry_elements.each do |entry_element|
-            # Grab the time and the description from the Result node
-            dummy_entry = Entry.new
-            extract_dates(entry_element, dummy_entry)
-            dummy_entry.description = ""
-            if entry_element.at_xpath("./ccr:Description/ccr:Text")
-              dummy_entry.description = entry_element.at_xpath("./ccr:Description/ccr:Text").content  
-            end
-            # Iterate over embedded tests
-            # Grab the values and the description from the Test nodes
-            # For each test, create an entry with the time from the Result,  the description a concatenation of the Result and Test descriptions, 
-            # and the value from the Test
-
-            tests = entry_element.xpath("./ccr:Test")
-            tests.each do |test|
-              entry = Entry.new
-              entry = dummy_entry.clone   # copies time and description
-              extract_codes(test, entry)
-              extract_value(test, entry)
-              extract_status(test, entry)
-              extract_dates(test, entry)
-              entry.description = dummy_entry.description + ": " + entry.description
-              if @check_for_usable
-                entry_list << entry if entry.usable?
-              else
-                entry_list << entry
-              end   
-            end          
-          end
-          entry_list        
-        end
-      end
-    end
-  end
-end