his_emr_api_lab 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cc795d01dc073e4556a1070e8e14199e49adff9419dfe02837008adb1aa6556
-  data.tar.gz: 9a61181925a0df93287b43446f0ace3b552972859f5f61248f7b8fb0fb085f56
+  metadata.gz: 778184a052cac6932ec700f03b99615024440af3944c371d0cfa997f357c525c
+  data.tar.gz: 045fb73daab53abc457c08152c5148251a6dccb239f0c76e09f3172007e44b6e
 SHA512:
-  metadata.gz: 4a571f53b3c2216c9bdb60bfc98f8b02ecef5053d72ac91d9a4680d8adb893a4085cd4b91c9fb873552f4e0e84b7e6990321140e0fe9795e1c64bf45c2bf5fb2
-  data.tar.gz: e169300a7f5e7b4c3755107895522275eaa3b71d17495cd14cac3cd5227d6b1f2529f8a27695f5301cbd7d92f20917c9e37dbd66be0babf49cdd98c3b3be3674
+  metadata.gz: 95f56b7a5d1b36565074904d49e5ff69b34fb57bed690a7bec5d269749c6813e094b4e02b397517523edd90e0714710376f489338788838fad775f3c724659db
+  data.tar.gz: 380096a9132eb857a4a321260593640eec0d6a5b08f661e97a1ba2396619eb5984c1aca488e364930dff737ff397b07865597b9ed321c7a93101c151a8d2566f

data/app/controllers/lab/labels_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lab
+  class LabelsController < ApplicationController
+    def print_order_label
+      order_id = params.require(:order_id)
+
+      label = LabellingService::OrderLabel.new(order_id)
+      send_data(label.print, type: 'application/label; charset=utf-8',
+                             stream: false,
+                             filename: "#{SecureRandom.hex(24)}.lbl",
+                             disposition: 'inline')
+    end
+  end
+end

data/app/controllers/lab/orders_controller.rb

@@ -14,7 +14,8 @@ module Lab
     def update
       specimen = params.require(:specimen).permit(:concept_id)
 
-      order = OrdersService.update_order(params[:id], specimen: specimen)
+      order = OrdersService.update_order(params[:id], specimen: specimen,
+                                                      force_update: params[:force_update])
 
       render json: order
     end

data/app/models/lab/lab_order.rb

@@ -35,7 +35,11 @@ module Lab
             class_name: 'Observation',
             foreign_key: :order_id
 
-    default_scope { joins(:order_type).merge(OrderType.where(name: Lab::Metadata::ORDER_TYPE_NAME)) }
+    default_scope do
+      joins(:order_type)
+        .merge(OrderType.where(name: Lab::Metadata::ORDER_TYPE_NAME))
+        .where.not(concept_id: ConceptName.where(name: 'Tests ordered').select(:concept_id))
+    end
 
     def self.prefetch_relationships
       includes(:reason_for_test,

data/app/models/lab/lab_result.rb

@@ -17,5 +17,15 @@ module Lab
                 end),
                class_name: 'Observation',
                foreign_key: :obs_group_id
+
+    def void(reason)
+      children.each do |measure|
+        # Need to have a LabResultMeasure model that privately handles it's children
+        measure.children.each { |provider| provider.void(reason) }
+        measure.void(reason)
+      end
+
+      super(reason)
+    end
   end
 end

data/app/models/lab/lab_test.rb

@@ -10,5 +10,10 @@ module Lab
             -> { where(concept: ConceptName.where(name: Lab::Metadata::TEST_RESULT_CONCEPT_NAME)) },
             class_name: '::Lab::LabResult',
             foreign_key: :obs_group_id
+
+    def void(reason)
+      result&.void(reason)
+      super(reason)
+    end
   end
 end

data/app/services/lab/labelling_service/order_label.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'auto12epl'
+
+module Lab
+  module LabellingService
+    ##
+    # Prints an order label for order with given accession number.
+    class OrderLabel
+      attr_reader :order
+
+      def initialize(order_id)
+        @order = Lab::LabOrder.find(order_id)
+      end
+
+      def print
+        # NOTE: The arguments are passed into the method below not in the order
+        #       the method expects (eg patient_id is passed to middle_name field)
+        #       to retain compatibility with labels generated by the `lab test controller`
+        #       application of the NLIMS suite.
+        auto12epl.generate_epl(patient.given_name,
+                               patient.family_name,
+                               patient.nhid,
+                               patient.birthdate.strftime('%d/%^b/%Y'),
+                               '',
+                               patient.gender,
+                               '',
+                               drawer,
+                               '',
+                               specimen,
+                               reason_for_test,
+                               order.accession_number,
+                               order.accession_number)
+      end
+
+      def reason_for_test
+        return 'Unknown' unless order.reason_for_test
+
+        ConceptName.find_by_concept_id(order.reason_for_test.value_coded)&.name || 'Unknown'
+      end
+
+      def patient
+        return @patient if @patient
+
+        person = Person.find(order.patient_id)
+        person_name = PersonName.find_by_person_id(order.patient_id)
+        patient_identifier = PatientIdentifier.where(type: PatientIdentifierType.where(name: 'National id'),
+                                                     patient_id: order.patient_id)
+                                              .first
+
+        @patient = OpenStruct.new(
+          given_name: person_name.given_name,
+          family_name: person_name.family_name,
+          birthdate: person.birthdate,
+          gender: person.gender,
+          nhid: patient_identifier&.identifier || 'Unknown'
+        )
+      end
+
+      def drawer
+        return 'N/A' if order.concept_id == unknown_concept.concept_id
+
+        name = PersonName.find_by_person_id(order.creator)
+        return "#{name.given_name} #{name.family_name}" if name
+
+        user = User.find(order.creator)
+        user&.username || 'N/A'
+      end
+
+      def specimen
+        return 'N/A' if order.concept_id == unknown_concept.concept_id
+
+        ConceptName.find_by_concept_id(order.concept_id)&.name || 'Unknown'
+      end
+
+      def unknown_concept
+        ConceptName.find_by_name('Unknown')
+      end
+
+      def auto12epl
+        Auto12Epl.new
+      end
+    end
+  end
+end

data/app/services/lab/lims/api.rb

@@ -29,9 +29,16 @@ module Lab
       # given block until the queue is empty or connection is terminated
       # by calling method +choke+.
       def consume_orders(from: 0, limit: 30)
+        last_seq = { value: 0 }
+
         bum.binge_changes(since: from, limit: limit, include_docs: true) do |change|
+          next unless change['doc']['type']&.casecmp?('Order')
+
           yield OrderDTO.new(change['doc']), self
+          last_seq[:value] = self.last_seq
         end
+
+        last_seq[:value]
       end
 
       def create_order(order)

data/app/services/lab/lims/exceptions.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lab
+  module Lims
+    class LimsException < StandardError; end
+    class DuplicateNHID < LimsException; end
+    class MissingAccessionNumber < LimsException; end
+    class UnknownSpecimenType < LimsException; end
+    class UnknownTestType < LimsException; end
+  end
+end

data/app/services/lab/lims/migrator.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'parallel'
+
+require 'couch_bum/couch_bum'
+require 'logger_multiplexor'
+
+require 'concept'
+require 'concept_name'
+require 'drug_order'
+require 'encounter'
+require 'encounter_type'
+require 'observation'
+require 'order'
+require 'order_type'
+require 'patient'
+require 'patient_identifier'
+require 'patient_identifier_type'
+require 'person'
+require 'person_name'
+require 'program'
+require 'user'
+
+require 'lab/lab_encounter'
+require 'lab/lab_order'
+require 'lab/lab_result'
+require 'lab/lab_test'
+require 'lab/lims_order_mapping'
+require 'lab/lims_failed_import'
+
+require_relative '../orders_service'
+require_relative '../results_service'
+require_relative '../tests_service'
+require_relative '../../../serializers/lab/lab_order_serializer'
+require_relative '../../../serializers/lab/result_serializer'
+require_relative '../../../serializers/lab/test_serializer'
+
+require_relative 'order_dto'
+require_relative 'utils'
+
+module Lab
+  module Lims
+    module Migrator
+      class MigratorApi < Api
+        MAX_THREADS = 6
+
+        attr_reader :rejections
+
+        def consume_orders(from: nil, limit: 50_000)
+          Parallel.each(read_orders(from, limit),
+                        in_processes: MAX_THREADS,
+                        finish: order_pmap_post_processor(from)) do |row|
+            next unless row['doc']['type']&.casecmp?('Order')
+
+            User.current = Migrator.lab_user
+            yield OrderDTO.new(row['doc']), OpenStruct.new(last_seq: from)
+          end
+        end
+
+        def last_seq
+          return 0 unless File.exist?(last_seq_path)
+
+          File.open(last_seq_path, File::RDONLY) do |file|
+            last_seq = file.read&.strip
+            return last_seq.blank? ? nil : last_seq&.to_i
+          end
+        end
+
+        private
+
+        def last_seq_path
+          Rails.root.join('log/lims/migration-last-id.dat')
+        end
+
+        def order_pmap_post_processor(last_seq)
+          lambda do |item, index, result|
+            save_last_seq(last_seq + index)
+            status, reason = result
+            next unless status == :rejected
+
+            (@rejections ||= []) << OpenStruct.new(order: OrderDTO.new(item['doc']), reason: reason)
+          end
+        end
+
+        def save_last_seq(last_seq)
+          return unless last_seq
+
+          File.open(last_seq_path, File::WRONLY | File::CREAT, 0o644) do |file|
+            Rails.logger.debug("Process ##{Parallel.worker_number}: Saving last seq: #{last_seq}")
+            file.flock(File::LOCK_EX)
+            file.write(last_seq.to_s)
+            file.flush
+          end
+        end
+
+        def save_rejection(order_dto, reason); end
+
+        def read_orders(from, batch_size)
+          Enumerator.new do |enum|
+            loop do
+              start_key_param = from ? "&skip=#{from}" : ''
+              url = "_all_docs?include_docs=true&limit=#{batch_size}#{start_key_param}"
+
+              Rails.logger.debug("#{MigratorApi}: Pulling orders from LIMS CouchDB: #{url}")
+              response = bum.couch_rest :get, url
+
+              from ||= 0
+
+              break from if response['rows'].empty?
+
+              response['rows'].each do |row|
+                enum.yield(row)
+              end
+
+              from += response['rows'].size
+            end
+          end
+        end
+      end
+
+      class MigrationWorker < Worker
+        protected
+
+        def last_seq
+          lims_api.last_seq
+        end
+
+        def update_last_seq(_last_seq); end
+      end
+
+      def self.lab_user
+        user = User.find_by_username('lab_daemon')
+        return user if user
+
+        god_user = User.first
+
+        person = Person.create!(creator: god_user.user_id)
+        PersonName.create!(person: person, given_name: 'Lab', family_name: 'Daemon', creator: god_user.user_id)
+
+        User.create!(username: 'lab_daemon', person: person, creator: god_user.user_id)
+      end
+
+      def self.save_csv(filename, rows:, headers: nil)
+        CSV.open(filename, File::WRONLY | File::CREAT) do |csv|
+          csv << headers if headers
+          rows.each { |row| csv << row }
+        end
+      end
+
+      MIGRATION_REJECTIONS_CSV_PATH = Rails.root.join('log/lims/migration-rejections.csv')
+
+      def self.export_rejections(rejections)
+        headers = ['Accession number', 'NHID', 'First name', 'Last name', 'Reason']
+        rows = (rejections || []).map do |rejection|
+          [
+            rejection.order[:tracking_number],
+            rejection.order[:patient][:id],
+            rejection.order[:patient][:first_name],
+            rejection.order[:patient][:last_name],
+            rejection.reason
+          ]
+        end
+
+        save_csv(MIGRATION_REJECTIONS_CSV_PATH, headers: headers, rows: rows)
+      end
+
+      MIGRATION_FAILURES_CSV_PATH = Rails.root.join('log/lims/migration-failures.csv')
+
+      def self.export_failures
+        headers = ['Accession number', 'NHID', 'Reason', 'Difference']
+        rows = Lab::LimsFailedImport.all.map do |failure|
+          [
+            failure.tracking_number,
+            failure.patient_nhid,
+            failure.reason,
+            failure.diff
+          ]
+        end
+
+        save_csv(MIGRATION_FAILURES_CSV_PATH, headers: headers, rows: rows)
+      end
+
+      MIGRATION_LOG_PATH = Rails.root.join('log/lims/migration.log')
+
+      def self.start_migration
+        log_dir = Rails.root.join('log/lims')
+        Dir.mkdir(log_dir) unless File.exist?(log_dir)
+
+        logger = LoggerMultiplexor.new(Logger.new($stdout), MIGRATION_LOG_PATH)
+        logger.level = :debug
+        Rails.logger = logger
+        ActiveRecord::Base.logger = logger
+        # CouchBum.logger = logger
+
+        api = MigratorApi.new
+        worker = MigrationWorker.new(api)
+
+        worker.pull_orders
+      ensure
+        api && export_rejections(api.rejections)
+        export_failures
+      end
+    end
+  end
+end

data/app/services/lab/lims/order_dto.rb

@@ -1,153 +1,62 @@
 # frozen_string_literal: true
 
+require_relative './exceptions'
+
 module Lab
   module Lims
     ##
     # LIMS' Data Transfer Object for orders
     class OrderDTO < ActiveSupport::HashWithIndifferentAccess
-      class << self
-        include Utils
-
-        ##
-        # Takes a Lab::LabOrder and serializes it into a DTO
-        def from_order(order)
-          serialized_order = structify(Lab::LabOrderSerializer.serialize_order(order))
-
-          new(
-            tracking_number: serialized_order.accession_number,
-            sending_facility: current_facility_name,
-            receiving_facility: serialized_order.target_lab,
-            tests: serialized_order.tests.collect(&:name),
-            patient: format_patient(serialized_order.patient_id),
-            order_location: format_order_location(serialized_order.encounter_id),
-            sample_type: format_sample_type(serialized_order.specimen.name),
-            sample_status: format_sample_status(serialized_order.specimen.name),
-            districy: current_district, # yes districy [sic]...
-            priority: serialized_order.reason_for_test.name,
-            date_created: serialized_order.order_date,
-            test_results: format_test_results(serialized_order),
-            type: 'Order'
-          )
-        end
-
-        private
-
-        def format_order_location(encounter_id)
-          location_id = Encounter.select(:location_id).where(encounter_id: encounter_id)
-          location = Location.select(:name)
-                             .where(location_id: location_id)
-                             .first
-
-          location&.name
-        end
-
-        # Format patient into a structure that LIMS expects
-        def format_patient(patient_id)
-          person = Person.find(patient_id)
-          name = PersonName.find_by_person_id(patient_id)
-          national_id = PatientIdentifier.joins(:type)
-                                         .merge(PatientIdentifierType.where(name: 'National ID'))
-                                         .where(patient_id: patient_id)
-                                         .first
-          phone_number = PersonAttribute.joins(:type)
-                                        .merge(PersonAttributeType.where(name: 'Cell phone Number'))
-                                        .where(person_id: patient_id)
-                                        .first
-
-          {
-            first_name: name&.given_name,
-            last_name: name&.family_name,
-            id: national_id&.value,
-            phone_number: phone_number,
-            gender: person.gender,
-            email: nil
-          }
-        end
-
-        def format_sample_type(name)
-          name.casecmp?('Unknown') ? 'not_specified' : name
-        end
-
-        def format_sample_status(name)
-          name.casecmp?('Unknown') ? 'specimen_not_collected' : 'specimen_collected'
-        end
-
-        def format_test_results(order)
-          order.tests.each_with_object({}) do |test, results|
-            results[test.name] = {
-              results: test.result.each_with_object({}) do |measure, measures|
-                measures[measure.indicator.name] = { result_value: "#{measure.value_modifier}#{measure.value}" }
-              end,
-              result_date: test.result.first&.date,
-              result_entered_by: {}
-            }
-          end
-        end
-
-        def current_health_center
-          health_center = Location.current_health_center
-          raise 'Current health center not set' unless health_center
-
-          health_center
-        end
-
-        def current_district
-          unless current_health_center.parent
-            raise "Current health center ##{current_health_center.id} is not associated with any district"
-          end
-
-          current_health_center.city_village || current_health_center.parent.name
-        end
-
-        def current_facility_name
-          current_health_center.name
-        end
-      end
+      include Utils
 
       ##
       # Unpacks a LIMS order into an object that OrdersService can handle
-      def to_order_service_params(lims_order)
+      def to_order_service_params(patient_id:)
         ActiveSupport::HashWithIndifferentAccess.new(
           program_id: lab_program.program_id,
-          patient_id: patient.patient_id,
-          specimen_type: { concept_id: specimen_type_id(lims_order.sample_type) },
-          tests: lims_order.tests&.map { |test| { concept_id: test_type_id(test) } },
-          requesting_clinician: requesting_clinician(lims_order.who_order_test),
-          start_date: start_date(lims_order.date_created),
-          target_lab: facility_name(lims_order.receiving_facility),
-          order_location: facility_name(lims_order.sending_facility),
-          reason_for_test: reason_for_test(lims_order.sample_priority)
+          accession_number: self['tracking_number'],
+          patient_id: patient_id,
+          specimen: { concept_id: specimen_type_id },
+          tests: self['tests']&.map { |test| { concept_id: test_type_id(test) } },
+          requesting_clinician: requesting_clinician,
+          date: start_date,
+          target_lab: facility_name(self['receiving_facility']),
+          order_location: facility_name(self['sending_facility']),
+          reason_for_test: reason_for_test
         )
       end
 
       private
 
       # Translates a LIMS specimen name to an OpenMRS concept_id
-      def specimen_type_id(lims_specimen_name)
-        if lims_specimen_name == 'specimen_not_collected'
-          return ConceptName.select(:concept_id).find_by_name!('Unknown')
+      def specimen_type_id
+        lims_specimen_name = self['sample_type']
+
+        if %w[specimen_not_collected not_assigned].include?(lims_specimen_name)
+          return ConceptName.select(:concept_id).find_by_name!('Unknown').concept_id
         end
 
-        concept = ConceptName.select(:concept_id).find_by_name(lims_specimen_name)
+        concept = Utils.find_concept_by_name(lims_specimen_name)
         return concept.concept_id if concept
 
-        raise "Unknown specimen name: #{lims_specimen_name}"
+        raise UnknownSpecimenType, "Unknown specimen name: #{lims_specimen_name}"
       end
 
       # Translates a LIMS test type name to an OpenMRS concept_id
       def test_type_id(lims_test_name)
-        concept = ConceptName.select(:concept_id).find_by_name(lims_test_name)
+        lims_test_name = Utils.translate_test_name(lims_test_name)
+        concept = Utils.find_concept_by_name(lims_test_name)
         return concept.concept_id if concept
 
-        raise "Unknown test type: #{lims_test_name}"
+        raise UnknownTestType, "Unknown test type: #{lims_test_name}"
       end
 
       # Extract requesting clinician name from LIMS
-      def requesting_clinician(lims_user)
+      def requesting_clinician
         # TODO: Extend requesting clinician to an obs tree having extra parameters
         # like phone number and ID to closely match the lims user.
-        first_name = lims_user.first_name || ''
-        last_name = lims_user.last_name || ''
+        first_name = self['who_order_test']['first_name'] || ''
+        last_name = self['who_order_test']['last_name'] || ''
 
         if first_name.blank? && last_name.blank?
           logger.warn('Missing requesting clinician name')
@@ -157,8 +66,8 @@ module Lab
         "#{first_name} #{last_name}"
       end
 
-      def start_date(lims_order_date_created)
-        lims_order_date_created.to_datetime
+      def start_date
+        Utils.parse_date(self['date_created'])
       end
 
       # Parses a LIMS facility name
@@ -168,9 +77,19 @@ module Lab
         lims_target_lab
       end
 
-      # Translates a LIMS priority to a concept_id
-      def reason_for_test(lims_sample_priority)
-        ConceptName.find_by_name!(lims_sample_priority).concept_id
+      # Translates a LIMS sample priority to a concept_id
+      def reason_for_test
+        return unknown_concept.concept_id unless self['sample_priority']
+
+        ConceptName.find_by_name!(self['sample_priority']).concept_id
+      end
+
+      def lab_program
+        Program.find_by_name!(Lab::Metadata::LAB_PROGRAM_NAME)
+      end
+
+      def unknown_concept
+        ConceptName.find_by_name!('Unknown')
       end
     end
   end