his_emr_api_lab 1.1.21 → 1.1.22

data/app/serializers/lab/lab_order_serializer.rb

@@ -1,55 +0,0 @@
-# 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.start_date,
-          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)
-          },
-          tests: tests.map do |test|
-            result_obs = test.children.first
-
-            {
-              id: test.obs_id,
-              concept_id: test.value_coded,
-              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

@@ -1,36 +0,0 @@
-# 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)
-
-        return [value, field.split('_')[1]] if value
-      end
-
-      [nil, 'unknown']
-    end
-  end
-end

data/app/serializers/lab/test_serializer.rb

@@ -1,29 +0,0 @@
-# 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,
-        concept_id: test.value_coded,
-        name: ConceptName.find_by_concept_id(test.value_coded)&.name,
-        order: {
-          id: order.order_id,
-          concept_id: order.concept_id,
-          name: ConceptName.find_by_concept_id(order.concept_id)&.name,
-          accession_number: order.accession_number
-        },
-        result: if result
-                  {
-                    id: result.obs_id,
-                    modifier: result.value_modifier,
-                    value: result.value_text
-                  }
-                end
-      }
-    end
-  end
-end

data/app/services/lab/accession_number_service.rb

@@ -1,77 +0,0 @@
-# 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

@@ -1,82 +0,0 @@
-# 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

@@ -1,106 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,53 +0,0 @@
-# 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