his_emr_api_lab 1.1.22 → 1.1.23

data/app/services/lab/accession_number_service.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Lab
+  # Responsible for the generation of tracking numbers
+  module AccessionNumberService
+    class << self
+      # Returns the next accession number on the given date or today.
+      #
+      # Throws:
+      #   RangeError - If date is greater than system date
+      def next_accession_number(date = nil)
+        date = validate_date(date || Date.today)
+        counter = find_counter(date)
+
+        counter.with_lock do
+          accession_number = format_accession_number(date, counter.value)
+          counter.value += 1
+          counter.save!
+
+          return accession_number
+        end
+      end
+
+      private
+
+      def find_counter(date)
+        counter = Lab::LabAccessionNumberCounter.find_by(date: date)
+        return counter if counter
+
+        Lab::LabAccessionNumberCounter.create(date: date, value: 1)
+      end
+
+      # Checks if date does not exceed system date
+      def validate_date(date)
+        return date unless date > Date.today
+
+        raise RangeError, "Specified date exceeds system date: #{date} > #{Date.today}"
+      end
+
+      def format_accession_number(date, counter)
+        year = format_year(date.year)
+        month = format_month(date.month)
+        day = format_day(date.day)
+
+        "X#{site_code}#{year}#{month}#{day}#{counter}"
+      end
+
+      def format_year(year)
+        (year % 100).to_s.rjust(2, '0')
+      end
+
+      # It's base 32 that uses letters for values 10+ but the letters
+      # are ordered in a way that seems rather arbitrary
+      # (see #get_day in https://github.com/HISMalawi/nlims_controller/blob/3c0faf1cb6572a11cb3b9bd1ea8444f457d01fd7/lib/tracking_number_service.rb#L58)
+      DAY_NUMBERING_SYSTEM = %w[1 2 3 4 5 6 7 8 9 A B C E F G H Y J K Z M N O P Q R S T V W X].freeze
+
+      def format_day(day)
+        DAY_NUMBERING_SYSTEM[day - 1]
+      end
+
+      def format_month(month)
+        # Months use a base 13 numbering system that's just a subset of the
+        # numbering system used for days
+        format_day(month)
+      end
+
+      def site_code
+        property = GlobalProperty.find_by(property: 'site_prefix')
+        value = property&.property_value&.strip
+
+        raise "Global property 'site_prefix' not set" unless value
+
+        value
+      end
+    end
+  end
+end

data/app/services/lab/concepts_service.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Lab
+  # A read-only repository of sort for all lab-centric concepts.
+  module ConceptsService
+    def self.test_types(name: nil, specimen_type: nil)
+      test_types = ConceptSet.find_members_by_name(Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
+      test_types = test_types.filter_members(name: name) if name
+
+      unless specimen_type
+        return test_types.joins('INNER JOIN concept_name ON concept_set.concept_id = concept_name.concept_id')
+                         .select('concept_name.name, concept_name.concept_id')
+                         .group('concept_name.concept_id')
+      end
+
+      # Filter out only those test types that have the specified specimen
+      # type.
+      specimen_types = ConceptSet.find_members_by_name(Lab::Metadata::SPECIMEN_TYPE_CONCEPT_NAME)
+                                 .filter_members(name: specimen_type)
+                                 .select(:concept_id)
+
+      concept_set = ConceptSet.where(
+        concept_id: specimen_types,
+        concept_set: test_types.select(:concept_id)
+      )
+
+      concept_set.joins('INNER JOIN concept_name ON concept_set.concept_set = concept_name.concept_id')
+                 .select('concept_name.concept_id, concept_name.name')
+                 .group('concept_name.concept_id')
+    end
+
+    def self.specimen_types(name: nil, test_type: nil)
+      specimen_types = ConceptSet.find_members_by_name(Lab::Metadata::SPECIMEN_TYPE_CONCEPT_NAME)
+      specimen_types = specimen_types.filter_members(name: name) if name
+
+      unless test_type
+        return specimen_types.select('concept_name.concept_id, concept_name.name')
+                             .joins('INNER JOIN concept_name ON concept_name.concept_id = concept_set.concept_id')
+                             .group('concept_name.concept_id')
+      end
+
+      # Retrieve only those specimen types that belong to concept
+      # set of the selected test_type
+      test_types = ConceptSet.find_members_by_name(Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
+                             .filter_members(name: test_type)
+                             .select(:concept_id)
+
+      concept_set = ConceptSet.where(
+        concept_id: specimen_types.select(:concept_id),
+        concept_set: test_types
+      )
+
+      concept_set.select('concept_name.concept_id, concept_name.name')
+                 .joins('INNER JOIN concept_name ON concept_name.concept_id = concept_set.concept_id')
+                 .group('concept_name.concept_id')
+    end
+
+    def self.test_result_indicators(test_type_id)
+      # Verify that the specified test_type is indeed a test_type
+      test = ConceptSet.find_members_by_name(Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
+                       .where(concept_id: test_type_id)
+                       .select(:concept_id)
+
+      # From the members above, filter out only those concepts that are result indicators
+      measures = ConceptSet.find_members_by_name(Lab::Metadata::TEST_RESULT_INDICATOR_CONCEPT_NAME)
+                           .select(:concept_id)
+
+      ConceptSet.where(concept_set: measures, concept_id: test)
+                .joins('INNER JOIN concept_name AS measure ON measure.concept_id = concept_set.concept_set')
+                .select('measure.concept_id, measure.name')
+                .group('measure.concept_id')
+                .map { |concept| { name: concept.name, concept_id: concept.concept_id } }
+    end
+
+    def self.reasons_for_test
+      ConceptSet.find_members_by_name(Lab::Metadata::REASON_FOR_TEST_CONCEPT_NAME)
+                .joins('INNER JOIN concept_name ON concept_name.concept_id = concept_set.concept_id')
+                .select('concept_name.concept_id, concept_name.name')
+                .map { |concept| { name: concept.name, concept_id: concept.concept_id } }
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# 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,
+                               '',
+                               tests,
+                               reason_for_test,
+                               order.accession_number,
+                               order.accession_number)
+      end
+
+      def reason_for_test
+        return 'Unknown' unless order.reason_for_test
+
+        short_concept_name(order.reason_for_test.value_coded) || '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
+
+        drawer_id = User.find(order.discontinued_by || order.creator).person_id
+        draw_date = (order.discontinued_date || order.start_date).strftime('%d/%^b/%Y %H:%M:%S')
+
+        name = PersonName.find_by_person_id(drawer_id)
+        return "#{name.given_name} #{name.family_name} #{draw_date}" if name
+
+        user = User.find_by_user_id(drawer_id)
+        user ? "#{user.username} #{draw_date}" : '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 tests
+        tests = order.tests.map do |test|
+          name = short_concept_name(test.value_coded) || 'Unknown'
+
+          next 'VL' if name.match?(/Viral load/i)
+
+          name.size > 7 ? name[0..6] : name
+        end
+
+        tests.join(', ')
+      end
+
+      def short_concept_name(concept_id)
+        ConceptName.where(concept_id: concept_id)
+                   .min_by { |concept| concept.name.size }
+                   &.name
+      end
+
+      def unknown_concept
+        ConceptName.find_by_name('Unknown')
+      end
+
+      def auto12epl
+        Auto12Epl.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lab
+  module Lims
+    module Api
+      ##
+      # A LIMS Api wrappper that does nothing really.
+      #
+      # Primarily meant as a dummy for testing environments.
+      class BlackholeApi
+        def create_order(order_dto); end
+
+        def update_order(order_dto); end
+
+        def void_order(order_dto); end
+
+        def consume_orders(&_block); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'couch_bum/couch_bum'
+
+require_relative '../config'
+
+module Lab
+  module Lims
+    module Api
+      ##
+      # Talk to LIMS like a boss
+      class CouchDbApi
+        attr_reader :bum
+
+        def initialize(config: nil)
+          config ||= Config.couchdb
+
+          @bum = CouchBum.new(protocol: config['protocol'],
+                              host: config['host'],
+                              port: config['port'],
+                              database: "#{config['prefix']}_order_#{config['suffix']}",
+                              username: config['username'],
+                              password: config['password'])
+        end
+
+        ##
+        # Consume orders from the LIMS queue.
+        #
+        # Retrieves orders from the LIMS queue and passes each order to
+        # given block until the queue is empty or connection is terminated
+        # by calling method +choke+.
+        def consume_orders(from: 0, limit: 30)
+          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
+          end
+        end
+
+        def create_order(order)
+          order = order.dup
+          order.delete('_id')
+
+          bum.couch_rest :post, '/', order
+        end
+
+        def update_order(id, order)
+          bum.couch_rest :put, "/#{id}", order
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+module Lab
+  module Lims
+    module Api
+      class MysqlApi
+        def self.start
+          instance = MysqlApi.new
+          orders_processed = 0
+          instance.consume_orders(from: 0, limit: 1000) do |order|
+            puts "Order ##{orders_processed}"
+            pp order
+            orders_processed += 1
+            puts
+          end
+        end
+
+        def initialize(processes: 1, on_merge_processes: nil)
+          @processes = processes
+          @on_merge_processes = on_merge_processes
+          @mysql_connection_pool = {}
+        end
+
+        def multiprocessed?
+          @processes > 1
+        end
+
+        def consume_orders(from: nil, limit: 1000)
+          loop do
+            specimens_to_process = specimens(from, limit)
+            break if specimens_to_process.size.zero?
+
+            processes = multiprocessed? ? @processes : 0
+            on_merge_processes = ->(_item, index, _result) { @on_merge_processes&.call(from + index) }
+
+            Parallel.map(specimens_to_process, in_processes: processes, finish: on_merge_processes) do |specimen|
+              User.current ||= Utils.lab_user
+
+              tests = specimen_tests(specimen['specimen_id'])
+              results = tests.each_with_object({}) do |test, object|
+                object[test['test_name']] = test_results(test['test_id'])
+              end
+
+              dto = make_order_dto(
+                specimen: specimen,
+                patient: specimen_patient(specimen['specimen_id']),
+                test_results: results,
+                specimen_status_trail: specimen_status_trail(specimen['specimen_id']),
+                test_status_trail: tests.each_with_object({}) do |test, trails|
+                  trails[test['test_name']] = test_status_trail(test['test_id'])
+                end
+              )
+
+              yield dto, OpenStruct.new(last_seq: from)
+            end
+
+            from += limit
+          end
+        end
+
+        def parallel_map(items, on_merge: nil, &block); end
+
+        private
+
+        def specimens(start_id, limit)
+          query = <<~SQL
+            SELECT specimen.id AS specimen_id,
+                   specimen.couch_id AS doc_id,
+                   specimen_types.name AS specimen_name,
+                   specimen.tracking_number,
+                   specimen.priority,
+                   specimen.target_lab,
+                   specimen.sending_facility,
+                   specimen.drawn_by_id,
+                   specimen.drawn_by_name,
+                   specimen.drawn_by_phone_number,
+                   specimen.ward_id,
+                   specimen_statuses.name AS specimen_status,
+                   specimen.district,
+                   specimen.date_created AS order_date
+            FROM specimen
+            INNER JOIN specimen_types ON specimen_types.id = specimen.specimen_type_id
+            INNER JOIN specimen_statuses ON specimen_statuses.id = specimen.specimen_status_id
+          SQL
+
+          query = "#{query} WHERE specimen.id > #{sql_escape(start_id)}" if start_id
+          query = "#{query} LIMIT #{limit.to_i}"
+
+          Rails.logger.debug(query)
+          query(query)
+        end
+
+        ##
+        # Pull patient associated with given specimen
+        def specimen_patient(specimen_id)
+          results = query <<~SQL
+            SELECT patients.patient_number AS nhid,
+                   patients.name,
+                   patients.gender,
+                   DATE(patients.dob) AS birthdate
+            FROM patients
+            INNER JOIN tests
+              ON tests.patient_id = patients.id
+              AND tests.specimen_id = #{sql_escape(specimen_id)}
+            LIMIT 1
+          SQL
+
+          results.first
+        end
+
+        def specimen_tests(specimen_id)
+          query <<~SQL
+            SELECT tests.id AS test_id,
+                   test_types.name AS test_name,
+                   tests.created_by AS drawn_by_name
+            FROM tests
+            INNER JOIN test_types ON test_types.id = tests.test_type_id
+            WHERE tests.specimen_id = #{sql_escape(specimen_id)}
+          SQL
+        end
+
+        def specimen_status_trail(specimen_id)
+          query <<~SQL
+            SELECT specimen_statuses.name AS status_name,
+                   specimen_status_trails.who_updated_id AS updated_by_id,
+                   specimen_status_trails.who_updated_name AS updated_by_name,
+                   specimen_status_trails.who_updated_phone_number AS updated_by_phone_number,
+                   specimen_status_trails.time_updated AS date
+            FROM specimen_status_trails
+            INNER JOIN specimen_statuses
+              ON specimen_statuses.id = specimen_status_trails.specimen_status_id
+            WHERE specimen_status_trails.specimen_id = #{sql_escape(specimen_id)}
+          SQL
+        end
+
+        def test_status_trail(test_id)
+          query <<~SQL
+            SELECT test_statuses.name AS status_name,
+                   test_status_trails.who_updated_id AS updated_by_id,
+                   test_status_trails.who_updated_name AS updated_by_name,
+                   test_status_trails.who_updated_phone_number AS updated_by_phone_number,
+                   COALESCE(test_status_trails.time_updated, test_status_trails.created_at) AS date
+            FROM test_status_trails
+            INNER JOIN test_statuses
+              ON test_statuses.id = test_status_trails.test_status_id
+            WHERE test_status_trails.test_id = #{sql_escape(test_id)}
+          SQL
+        end
+
+        def test_results(test_id)
+          query <<~SQL
+            SELECT measures.name AS measure_name,
+                   test_results.result,
+                   test_results.time_entered AS date
+            FROM test_results
+            INNER JOIN measures ON measures.id = test_results.measure_id
+            WHERE test_results.test_id = #{sql_escape(test_id)}
+          SQL
+        end
+
+        def make_order_dto(specimen:, patient:, test_status_trail:, specimen_status_trail:, test_results:)
+          drawn_by_first_name, drawn_by_last_name = specimen['drawn_by_name']&.split
+          patient_first_name, patient_last_name = patient['name'].split
+
+          OrderDTO.new(
+            _id: specimen['doc_id'].blank? ? SecureRandom.uuid : specimen['doc_id'],
+            _rev: '0',
+            tracking_number: specimen['tracking_number'],
+            date_created: specimen['order_date'],
+            sample_type: specimen['specimen_name'],
+            tests: test_status_trail.keys,
+            districy: specimen['district'], # districy [sic] - That's how it's named
+            order_location: specimen['ward_id'],
+            sending_facility: specimen['sending_facility'],
+            receiving_facility: specimen['target_lab'],
+            priority: specimen['priority'],
+            patient: {
+              id: patient['nhid'],
+              first_name: patient_first_name,
+              last_name: patient_last_name,
+              gender: patient['gender'],
+              birthdate: patient['birthdate'],
+              email: nil,
+              phone_number: nil
+            },
+            type: 'Order',
+            who_order_test: {
+              first_name: drawn_by_first_name,
+              last_name: drawn_by_last_name,
+              id: specimen['drawn_by_id'],
+              phone_number: specimen['drawn_by_phone_number']
+            },
+            sample_status: specimen['specimen_status'],
+            sample_statuses: specimen_status_trail.each_with_object({}) do |trail_entry, object|
+              first_name, last_name = trail_entry['updated_by_name'].split
+
+              object[format_date(trail_entry['date'])] = {
+                status: trail_entry['status_name'],
+                updated_by: {
+                  first_name: first_name,
+                  last_name: last_name,
+                  phone_number: trail_entry['updated_by_phone_number'],
+                  id: trail_entry['updated_by_id']
+                }
+              }
+            end,
+            test_statuses: test_status_trail.each_with_object({}) do |trail_entry, formatted_trail|
+              test_name, test_statuses = trail_entry
+
+              formatted_trail[test_name] = test_statuses.each_with_object({}) do |test_status, formatted_statuses|
+                updated_by_first_name, updated_by_last_name = test_status['updated_by_name'].split
+
+                formatted_statuses[format_date(test_status['date'])] = {
+                  status: test_status['status_name'],
+                  updated_by: {
+                    first_name: updated_by_first_name,
+                    last_name: updated_by_last_name,
+                    phone_number: test_status['updated_by_phone_number'],
+                    id: test_status['updated_by_id']
+                  }
+                }
+              end
+            end,
+            test_results: test_results.each_with_object({}) do |results_entry, formatted_results|
+              test_name, results = results_entry
+
+              formatted_results[test_name] = format_test_result_for_dto(test_name, specimen, results, test_status_trail)
+            end
+          )
+        end
+
+        def format_test_result_for_dto(test_name, specimen, results, test_status_trail)
+          return {} if results.size.zero?
+
+          result_create_event = test_status_trail[test_name]&.find do |trail_entry|
+            trail_entry['status_name'].casecmp?('drawn')
+          end
+
+          result_creator_first_name, result_creator_last_name = result_create_event&.fetch('updated_by_name')&.split
+          unless result_creator_first_name
+            result_creator_first_name, result_creator_last_name = specimen['drawn_by_name']&.split
+          end
+
+          {
+            results: results.each_with_object({}) do |result, formatted_measures|
+              formatted_measures[result['measure_name']] = {
+                result_value: result['result']
+              }
+            end,
+            date_result_entered: format_date(result_create_event&.fetch('date') || specimen['order_date'], :iso),
+            result_entered_by: {
+              first_name: result_creator_first_name,
+              last_name: result_creator_last_name,
+              phone_number: result_create_event&.fetch('updated_by_phone_number') || specimen['drawn_by_phone_number'],
+              id: result_create_event&.fetch('updated_by_id') || specimen['updated_by_id']
+            }
+          }
+        end
+
+        def mysql
+          return mysql_connection if mysql_connection
+
+          config = lambda do |key|
+            @config ||= Lab::Lims::Config.database
+            @config['default'][key] || @config['development'][key]
+          end
+
+          connection = Mysql2::Client.new(host: config['host'] || 'localhost',
+                                          username: config['username'] || 'root',
+                                          password: config['password'],
+                                          port: config['port'] || '3306',
+                                          database: config['database'],
+                                          reconnect: true)
+
+          self.mysql_connection = connection
+        end
+
+        def pid
+          return -1 if Parallel.worker_number.nil?
+
+          Parallel.worker_number
+        end
+
+        def mysql_connection=(connection)
+          @mysql_connection_pool[pid] = connection
+        end
+
+        def mysql_connection
+          @mysql_connection_pool[pid]
+        end
+
+        def query(sql)
+          Rails.logger.debug("#{MysqlApi}: #{sql}")
+          mysql.query(sql)
+        end
+
+        def sql_escape(value)
+          mysql.escape(value.to_s)
+        end
+
+        ##
+        # Lims has some weird date formatting standards...
+        def format_date(date, format = nil)
+          date = date&.to_time
+
+          case format
+          when :iso
+            date&.strftime('%Y-%m-%d %H:%M:%S')
+          else
+            date&.strftime('%Y%m%d%H%M%S')
+          end
+        end
+      end
+    end
+  end
+end