mahis_his_emr_api_lab 1.2.0

data/app/serializers/lab/lab_order_serializer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Lab
+  module LabOrderSerializer
+    def self.serialize_order(order, tests: nil, requesting_clinician: nil, reason_for_test: nil, target_lab: nil)
+      tests ||= order.voided == 1 ? voided_tests(order) : order.tests
+      requesting_clinician ||= order.requesting_clinician
+      reason_for_test ||= order.reason_for_test
+      target_lab = target_lab&.value_text || order.target_lab&.value_text || Location.current_health_center&.name
+      ActiveSupport::HashWithIndifferentAccess.new(
+        {
+          id: order.order_id,
+          order_id: order.order_id, # Deprecated: Link to :id
+          encounter_id: order.encounter_id,
+          order_date: order.date_created,
+          patient_id: order.patient_id,
+          accession_number: order.accession_number,
+          specimen: {
+            concept_id: order.concept_id,
+            name: concept_name(order.concept_id)
+          },
+          requesting_clinician: requesting_clinician&.value_text,
+          target_lab: target_lab,
+          reason_for_test: {
+            concept_id: reason_for_test&.value_coded,
+            name: concept_name(reason_for_test&.value_coded)
+          },
+          delivery_mode: order&.lims_acknowledgement_status&.acknowledgement_type,
+          tests: tests.map do |test|
+            result_obs = test.children.first
+
+            {
+              id: test.obs_id,
+              concept_id: test.value_coded,
+              uuid: test.uuid,
+              name: concept_name(test.value_coded),
+              result: result_obs && ResultSerializer.serialize(result_obs)
+            }
+          end
+        }
+      )
+    end
+
+    def self.concept_name(concept_id)
+      return concept_id unless concept_id
+
+      ConceptName.select(:name).find_by_concept_id(concept_id)&.name
+    end
+
+    def self.voided_tests(order)
+      concept = ConceptName.where(name: Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
+                           .select(:concept_id)
+      LabTest.unscoped.where(concept: concept, order: order, voided: true)
+    end
+  end
+end

data/app/serializers/lab/result_serializer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Lab
+  ##
+  # Serialize a Lab order result
+  module ResultSerializer
+    def self.serialize(result)
+      result.children.map do |measure|
+        value, value_type = read_value(measure)
+        concept_name = ConceptName.find_by_concept_id(measure.concept_id)
+
+        {
+          id: measure.obs_id,
+          indicator: {
+            concept_id: concept_name&.concept_id,
+            name: concept_name&.name
+          },
+          date: measure.obs_datetime,
+          value: value,
+          value_type: value_type,
+          value_modifier: measure.value_modifier
+        }
+      end
+    end
+
+    def self.read_value(measure)
+      %w[value_numeric value_coded value_boolean value_text].each do |field|
+        value = measure.send(field) if measure.respond_to?(field)
+
+        return [value, field.split('_')[1]] if value
+      end
+
+      [nil, 'unknown']
+    end
+  end
+end

data/app/serializers/lab/test_serializer.rb

@@ -0,0 +1,52 @@
+# rubocop:disable Lint/UnreachableLoop
+# frozen_string_literal: true
+
+module Lab
+  module TestSerializer
+    def self.serialize(test, order: nil, result: nil)
+      order ||= test.order
+      result ||= test.result
+      {
+        id: test.obs_id,
+        test_uuid: test.uuid,
+        concept_id: test.value_coded,
+        concept_uuid: test.value_coded ? Concept.find(test.value_coded)&.uuid : nil,
+        name: ConceptName.find_by_concept_id(test.value_coded)&.name,
+        order: {
+          id: order.order_id,
+          concept_id: order.concept_id,
+          concept_uuid: order.concept_id ? Concept.find(order.concept_id)&.uuid : nil,
+          name: ConceptName.find_by_concept_id(order.concept_id)&.name,
+          accession_number: order.accession_number
+        },
+        measures: result_mesures(result),
+        result: if result
+                  {
+                    id: result.obs_id,
+                    uuid: result.uuid,
+                    modifier: result.value_modifier,
+                    value: result.value_text
+                  }
+                end
+      }
+    end
+
+    def self.result_mesures(result)
+      if result&.measures.present?
+        return result&.measures&.map do |measure|
+          m = {}
+          m[:uuid] = measure.uuid
+          m[:concept_id] = measure.concept_id
+          m[:name] = ConceptName.find_by_concept_id(measure.concept_id)&.name
+          m[:modifier] = measure.value_modifier
+          m[:value] = measure&.value_text || measure&.value_numeric || measure&.value_boolean || measure&.value_coded || measure&.value_datetime || measure&.value_drug || measure&.value_complex || measure&.value_group
+          m
+        end
+      end
+
+      nil
+    end
+  end
+end
+
+# rubocop:enable Lint/UnreachableLoop

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/acknowledgement_service.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lab
+  # acknoledgement service for creating lab acknowledgements
+  module AcknowledgementService
+    class << self
+      def create_acknowledgement(params)
+        order = Order.find(params[:order_id])
+
+        Lab::LabAcknowledgement.find_by(order_id: order.id, test: params[:test])&.destroy
+
+        Lab::LabAcknowledgement.create!(order_id: order.id, test: params[:test], pushed: false,
+                                        acknowledgement_type: params[:entered_by] == 'LIMS' ? 'test_results_delivered_to_site_electronically' : 'test_results_delivered_to_site_manually',
+                                        date_received: params[:date_received])
+      end
+
+      def acknowledgements_pending_sync(batch_size)
+        Lab::LabAcknowledgement.where(pushed: false)
+                               .limit(batch_size)
+      end
+
+      def push_acknowledgement(acknowledgement, lims_api)
+        Rails.logger.info("Pushing acknowledgement ##{acknowledgement.order_id}")
+
+        acknowledgement_dto = Lab::Lims::AcknowledgementSerializer.serialize_acknowledgement(acknowledgement)
+        mapping = Lab::LimsOrderMapping.find_by(order_id: acknowledgement.order_id)
+
+        ActiveRecord::Base.transaction do
+          if mapping
+            Rails.logger.info("Updating acknowledgement ##{acknowledgement_dto[:tracking_number]} in LIMS")
+            response = lims_api.acknowledge(acknowledgement_dto)
+            Rails.logger.info("Info #{response}")
+            if response['status'] == 200 || response['message'] == 'results already delivered for test name given'
+              acknowledgement.pushed = true
+              acknowledgement.date_pushed = Time.now
+              acknowledgement.save!
+            else
+              Rails.logger.error("Failed to process acknowledgement for tracking number ##{acknowledgement_dto[:tracking_number]} in LIMS")
+            end
+          else
+            Rails.logger.info("No mapping found for acknowledgement ##{acknowledgement_dto[:tracking_number]}")
+          end
+        end
+      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 AND concept_name.voided = 0 AND concept_name.locale_preferred = 1')
+                         .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: Concept.find(test_type_id)&.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, measure.uuid')
+                .group('measure.concept_id')
+                .map { |concept| { name: concept.name, concept_id: concept.concept_id, uuid: concept.uuid } }
+    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, concept_name.uuid')
+                .map { |concept| { name: concept.name, concept_id: concept.concept_id, uuid: concept.uuid } }
+    end
+  end
+end

data/app/services/lab/json_web_token_service.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lab
+  # This class is used to encode and decode the JWT token
+  module JsonWebTokenService
+    class << self
+      SECRET_KEY = Rails.application.secrets.secret_key_base.to_s
+
+      def encode(payload, request_ip, exp = 18.hours.from_now)
+        payload[:exp] = exp.to_i
+        JWT.encode(payload, SECRET_KEY + request_ip)
+      end
+
+      def decode(token, request_ip)
+        decoded = JWT.decode(token, SECRET_KEY + request_ip)[0]
+        HashWithIndifferentAccess.new decoded
+      end
+    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/acknowledgement_serializer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lab
+  module Lims
+    ##
+    # Serialize a Lab::LabResult to LIMS' acknowledgement format
+    module AcknowledgementSerializer
+      class << self
+        include Utils
+
+        def serialize_acknowledgement(acknowledgement)
+          serialized_acknowledgement = Lims::Utils.structify(acknowledgement)
+          {
+            tracking_number: Lab::LabOrder.find(serialized_acknowledgement.order_id).accession_number,
+            test: ::ConceptName.where(concept_id: serialized_acknowledgement.test).first.name,
+            date_acknowledged: format_date(serialized_acknowledgement.date_received),
+            recipient_type: serialized_acknowledgement.acknowledgement_type
+          }
+        end
+
+        private
+
+        def format_date(date)
+          date.strftime('%Y-%m-%d %H:%M:%S')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Lab
+  module Lims
+    # This class is responsible for handling the acknowledgement of lab orders
+    class AcknowledgementWorker
+      attr_reader :lims_api
+
+      include Utils # for logger
+
+      SECONDS_TO_WAIT_FOR_ORDERS = 30
+
+      def initialize(lims_api)
+        @lims_api = lims_api
+      end
+
+      def push_acknowledgement(batch_size: 1000, wait: false)
+        loop do
+          logger.info('Looking for new acknowledgements to push to LIMS...')
+          acknowledgements = Lab::AcknowledgementService.acknowledgements_pending_sync(batch_size).all
+
+          logger.debug("Found #{acknowledgements.size} acknowledgements...")
+          acknowledgements.each do |acknowledgement|
+            Lab::AcknowledgementService.push_acknowledgement(acknowledgement, @lims_api)
+          rescue GatewayError => e
+            logger.error("Failed to push acknowledgement ##{acknowledgement.order_id}: #{e.class} - #{e.message}")
+          end
+
+          break unless wait
+
+          logger.info('Waiting for acknowledgements...')
+          sleep(Lab::Lims::Config.updates_poll_frequency)
+        end
+      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