his_emr_api_lab 2.1.9.pre.beta → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6c20f1ba07edd60ba5795eaaef1ca3f34395060b1f9ed0160a5513777d657d0
-  data.tar.gz: d16b695b3592233474fa9bbc2f90c85db7d04161a02f8107c56f92fd4e82a9fb
+  metadata.gz: c59744a50921b0f2244c94e052d4d66cbf39096485f99755e84f9cb66c311a0b
+  data.tar.gz: 989cc056aa59acbcd9d24977d3fc34b330cd1793db5d35908ccce44ca08dab34
 SHA512:
-  metadata.gz: 035cf4578ee6f60ba3406a66f88ea33cc54ea7d85ab38524b7e6ae54c9b4b80e03fe2938fc34d047e72df9423b71b8eba1f40004a8fd688555b56c3aebb81605
-  data.tar.gz: feda70dff8797923f46078a42429b274d7562eb5105a5d43c1d746f744436c6c516847aa2ef68d7b235f1d1a216981e10d4c707bc6f4fb45372d6b867c412a2a
+  metadata.gz: 22429cb56bfb9c5af91e5b44e2da11b66551ac89d084eeea45f5b16bb06daf5cc4f99d41cb5f2e4f3d5a38443fb62c15e5a30a14c5e5fff85006a3233d8f71de
+  data.tar.gz: 622a040596dc790f1d5a3c05469f7afe131badeca6313eb2412f8da378e632b7b28643c6a12eba6f02c618b9bed680722a635ce6e2e57ea6863872eb5e9b0966

data/README.md

@@ -22,25 +22,25 @@ For details on how to perform these operations please see the
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'lab', git: 'https://github.com/EGPAFMalawiHIS/HIS-EMR-API-Lab', branch: 'development'
+gem 'his_emr_api_lab', git: 'https://github.com/EGPAFMalawiHIS/HIS-EMR-API-Lab', branch: 'development'
 ```
 
 And then execute:
 
 ```bash
-$ bundle install lab
+$ bundle install 
 ```
 
 Or install it yourself as:
 
 ```bash
-$ gem install lab
+$ gem install his_emr_api_lab
 ```
 
 Finally run:
 
 ```bash
-$ bundle exec rails lab:install
+$ bundle exec rails his_emr_api_lab:install
 ```
 
 ## Configuration
@@ -66,6 +66,19 @@ but too much a departure from it is frowned upon. For example, you will be forgi
 for writing a method with 15 to 20 lines if you clearly justify why you couldn't
 break that method into multiple smaller methods.
 
+## Publishing
+
+To publish a new version of the gem, first update the version number in
+`lib/lab/version.rb` and then run the following command:
+
+```bash
+$ gem build his_emr_api_lab.gemspec
+$ gem push his_emr_api_lab-<version>.gem  
+```
+Make sure to replace `<version>` with the version number you set in `lib/lab/version.rb`.
+
+NB: You need to have an account on [rubygems.org](https://rubygems.org/) and permission to publish gems.
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/controllers/lab/orders_controller.rb

@@ -2,6 +2,7 @@
 
 module Lab
   class OrdersController < ApplicationController
+    skip_before_action :authenticate, only: %i[order_status order_result summary]
     before_action :authenticate_request, only: %i[order_status order_result summary]
 
     def create
@@ -52,7 +53,8 @@ module Lab
     end
 
     def order_status
-      order_params = params.permit(:tracking_number, :status, :status_time, :comments)
+      order_params = params.permit(:tracking_number, :status, :status_time, :comments, :status_id,
+                                    updated_by: [:first_name, :last_name, :id, :phone_number])
       OrdersService.update_order_status(order_params)
       render json: { message: "Status for order #{order_params['tracking_number']} successfully updated" }, status: :ok
     end
@@ -76,8 +78,26 @@ module Lab
     private
 
     def authenticate_request
-      decoded_user = authorize_request
-      user(decoded_user)
+      header = request.headers['Authorization']
+      content = header.split(' ')
+      auth_scheme = content.first
+      unless header
+        errors = ['Authorization token required']
+        render json: { errors: errors }, status: :unauthorized
+        return false
+      end
+      unless auth_scheme == 'Bearer'
+        errors = ['Authorization token bearer scheme required']
+        render json: { errors: errors }, status: :unauthorized
+        return false
+      end
+      process_token(content.last)
+    end
+
+    def process_token(token)
+      browser = Browser.new(request.user_agent)
+      decoded = Lab::JsonWebTokenService.decode(token, request.remote_ip + browser.name + browser.version)
+      user(decoded)
     end
 
     def user(decoded)

data/app/jobs/lab/process_lab_result_job.rb

@@ -7,11 +7,8 @@ module Lab
     queue_as :default
     def perform(results_obs_id, serializer, result_enter_by)
       Rails.logger.info("Lab::ProcessLabResultJob: Processing result completion for #{serializer}")
-      # set location context for the job based on the order's encounter to ensure proper context for any operations performed in the job
       results_obs = Lab::LabResult.unscoped.find(results_obs_id)
-      encounter = Encounter.unscoped.find_by(encounter_id: results_obs.encounter_id)
-      Location.current = Location.find(encounter.location_id) if encounter&.location_id
       Lab::ResultsService.process_result_completion(results_obs, serializer, result_enter_by)
     end
   end
-end
+end

data/app/jobs/lab/update_patient_orders_job.rb

@@ -10,8 +10,7 @@ module Lab
       Rails.logger.info('Initialising LIMS REST API...')
 
       User.current = Lab::Lims::Utils.lab_user
-      # Set location from patient's most recent encounter to ensure proper context
-      set_location_from_patient_encounter(patient_id)
+      Location.current = Location.find_by_name('ART clinic')
 
       lockfile = Rails.root.join('tmp', "update-patient-orders-#{patient_id}.lock")
 
@@ -29,53 +28,5 @@ module Lab
 
       File.unlink(lockfile) if done
     end
-
-    private
-
-    def set_location_from_patient_encounter(patient_id)
-      Rails.logger.info("Setting location context for patient #{patient_id}")
-
-      # Strategy 1: Find location from patient's most recent order (ANY order type)
-      recent_order = Order.unscoped
-                          .where(patient_id: patient_id)
-                          .order(start_date: :desc)
-                          .first
-
-      if recent_order
-        encounter = Encounter.unscoped.find_by(encounter_id: recent_order.encounter_id)
-        if encounter&.location_id
-          Location.current = Location.find(encounter.location_id)
-          Rails.logger.info("Location set from patient's recent order: #{Location.current.name} (ID: #{Location.current.location_id})")
-          return
-        end
-      end
-
-      # Strategy 2: Find location from patient's most recent encounter
-      recent_encounter = Encounter.unscoped
-                                  .where(patient_id: patient_id)
-                                  .order(encounter_datetime: :desc)
-                                  .first
-
-      if recent_encounter&.location_id
-        Location.current = Location.find(recent_encounter.location_id)
-        Rails.logger.info("Location set from patient's recent encounter: #{Location.current.name} (ID: #{Location.current.location_id})")
-        return
-      end
-
-      # Fallback chain: Try multiple options to ensure location is ALWAYS set
-      Location.current ||= begin
-        Location.current_health_center
-      rescue StandardError
-        nil
-      end
-      Location.current ||= Location.first
-
-      if Location.current
-        Rails.logger.info("Location set to fallback: #{Location.current.name} (ID: #{Location.current.location_id})")
-      else
-        Rails.logger.error('CRITICAL: Could not set Location.current - no locations found in database!')
-        raise 'No locations available in database'
-      end
-    end
   end
 end

data/app/jobs/lab/void_order_job.rb

@@ -8,14 +8,10 @@ module Lab
       Rails.logger.info("Voiding order ##{order_id} in LIMS")
 
       User.current = Lab::Lims::Utils.lab_user
-      # Set location from order's encounter to ensure proper context
-      order = Lab::LabOrder.unscoped.find(order_id)
-      encounter = Encounter.unscoped.find_by(encounter_id: order.encounter_id)
-      Location.current = Location.find(encounter.location_id) if encounter&.location_id
-      Location.current ||= Location.find_by_name('ART clinic')
+      Location.current = Location.find_by_name('ART clinic')
 
       worker = Lab::Lims::PushWorker.new(Lab::Lims::ApiFactory.create_api)
-      worker.push_order(order)
+      worker.push_order(Lab::LabOrder.unscoped.find(order_id))
     end
   end
 end

data/app/models/lab/lab_order.rb

@@ -8,6 +8,11 @@ module Lab
 
         -> { where(concept:) }
       end
+
+      # Cache the concept ID to avoid lookups in association scopes
+      def order_status_concept_id
+        @order_status_concept_id ||= ConceptName.find_by(name: 'Lab Order Status')&.concept_id
+      end
     end
 
     has_many :tests,
@@ -44,12 +49,20 @@ module Lab
             class_name: '::Lab::LimsOrderMapping',
             foreign_key: :order_id
 
+    # Status trails are stored as observations with concept 'Lab Order Status'
+    has_many :status_trail_observations,
+             lambda {
+               unscoped.where(voided: 0, concept_id: Lab::LabOrder.order_status_concept_id).order(obs_datetime: :asc)
+             },
+             class_name: 'Observation',
+             foreign_key: :order_id
+
     default_scope do
       joins(:order_type)
         .merge(OrderType.where(name: [
-          Lab::Metadata::ORDER_TYPE_NAME, 
-          Lab::Metadata::HTS_ORDER_TYPE_NAME
-        ]))
+                                 Lab::Metadata::ORDER_TYPE_NAME,
+                                 Lab::Metadata::HTS_ORDER_TYPE_NAME
+                               ]))
         .where.not(concept_id: ConceptName.where(name: 'Tests ordered').select(:concept_id))
     end
 
@@ -57,11 +70,13 @@ module Lab
     scope :not_drawn, -> { where(concept_id: ConceptName.where(name: 'Unknown').select(:concept_id)) }
 
     def self.prefetch_relationships
-      includes(:reason_for_test,
-               :requesting_clinician,
-               :target_lab,
-               :comment_to_fulfiller,
-               tests: [:result])
+      # NOTE: status_trail_observations and test results are not preloaded due to
+      # Rails limitations with eager loading unscoped associations. They load on-demand instead.
+      preload(:reason_for_test,
+              :requesting_clinician,
+              :target_lab,
+              :comment_to_fulfiller,
+              :tests)
     end
   end
 end

data/app/models/lab/lab_result.rb

@@ -3,9 +3,9 @@
 module Lab
   class LabResult < Observation
     def children
-      Observation.where(obs_group_id: obs_id, voided: 0)
+      Observation.unscoped.where(obs_group_id: obs_id, voided: 0)
     end
-    
+
     alias measures children
 
     default_scope do

data/app/models/lab/lab_test.rb

@@ -6,14 +6,33 @@ module Lab
       where(concept: ConceptName.where(name: Lab::Metadata::TEST_TYPE_CONCEPT_NAME))
     end
 
+    # Cache the concept IDs as class methods to avoid lookups in association scopes
+    def self.test_status_concept_id
+      @test_status_concept_id ||= ConceptName.find_by(name: 'Lab Test Status')&.concept_id
+    end
+
+    def self.test_result_concept_id
+      @test_result_concept_id ||= ConceptName.find_by(name: Lab::Metadata::TEST_RESULT_CONCEPT_NAME)&.concept_id
+    end
+
     has_one :result,
-            -> { where(concept: ConceptName.where(name: Lab::Metadata::TEST_RESULT_CONCEPT_NAME)) },
+            -> { unscoped.where(voided: 0, concept_id: Lab::LabTest.test_result_concept_id) },
             class_name: 'Lab::LabResult',
             foreign_key: :obs_group_id
 
+    # Status trails are stored as observations with concept 'Lab Test Status'
+    # They are linked via obs_group_id (this test obs is the parent)
+    has_many :status_trail_observations,
+             lambda {
+               unscoped.where(voided: 0, concept_id: Lab::LabTest.test_status_concept_id).order(obs_datetime: :asc)
+             },
+             class_name: 'Observation',
+             foreign_key: :obs_group_id,
+             primary_key: :obs_id
+
     def void(reason)
       result&.void(reason)
-      super(reason)
+      super
     end
   end
 end

data/app/serializers/lab/lab_order_serializer.rb

@@ -9,9 +9,8 @@ module Lab
       reason_for_test ||= order.reason_for_test
       target_lab = target_lab&.value_text || order.target_lab&.value_text || Location.current_health_center&.name
 
-      # Use unscoped to find encounter across all locations
-      encounter = Encounter.unscoped.find_by_encounter_id(order.encounter_id)
-      program = Program.find_by_program_id(encounter.program_id)
+      encounter = Encounter.find_by_encounter_id(order.encounter_id)
+      program = Program.find_by_program_id(encounter&.program_id)
 
       ActiveSupport::HashWithIndifferentAccess.new(
         {
@@ -20,8 +19,8 @@ module Lab
           order_id: order.order_id, # Deprecated: Link to :id
           encounter_id: order.encounter_id,
           order_date: order.start_date,
-          location_id: encounter.location_id,
-          program_id: encounter.program_id,
+          location_id: encounter&.location_id,
+          program_id: encounter&.program_id,
           program_name: program&.name,
           patient_id: order.patient_id,
           accession_number: order.accession_number,
@@ -37,8 +36,10 @@ module Lab
             name: concept_name(reason_for_test&.value_coded)
           },
           delivery_mode: order&.lims_acknowledgement_status&.acknowledgement_type,
+          order_status: latest_order_status(order),
+          order_status_trail: serialize_order_status_trail(order),
           tests: tests.map do |test|
-            result_obs = test.children.first
+            result_obs = test.result
 
             {
               id: test.obs_id,
@@ -46,7 +47,9 @@ module Lab
               uuid: test.uuid,
               name: concept_name(test.value_coded),
               test_method: test_method(order, test.value_coded),
-              result: result_obs && ResultSerializer.serialize(result_obs)
+              result: result_obs && ResultSerializer.serialize(result_obs),
+              test_status: latest_test_status(test),
+              test_status_trail: serialize_test_status_trail(test)
             }
           end
         }
@@ -75,5 +78,72 @@ module Lab
                            .select(:concept_id)
       LabTest.unscoped.where(concept:, order:, voided: true)
     end
+
+    def self.latest_order_status(order)
+      # Query obs table for latest order status
+      latest_obs = order.status_trail_observations.last
+      return nil unless latest_obs
+
+      updated_by = parse_comments_json(latest_obs.comments)
+
+      {
+        status_id: 0, # status_id not used with text values
+        status: latest_obs.value_text,
+        timestamp: latest_obs.obs_datetime,
+        updated_by: updated_by
+      }
+    end
+
+    def self.serialize_order_status_trail(order)
+      # Query obs table for order status trail
+      order.status_trail_observations.map do |obs|
+        updated_by = parse_comments_json(obs.comments)
+
+        {
+          status_id: 0, # status_id not used with text values
+          status: obs.value_text,
+          timestamp: obs.obs_datetime,
+          updated_by: updated_by
+        }
+      end
+    end
+
+    def self.latest_test_status(test)
+      # Query obs table for latest test status
+      latest_obs = test.status_trail_observations.last
+      return nil unless latest_obs
+
+      updated_by = parse_comments_json(latest_obs.comments)
+
+      {
+        status_id: 0, # status_id not used with text values
+        status: latest_obs.value_text,
+        timestamp: latest_obs.obs_datetime,
+        updated_by: updated_by
+      }
+    end
+
+    def self.serialize_test_status_trail(test)
+      # Query obs table for test status trail
+      test.status_trail_observations.map do |obs|
+        updated_by = parse_comments_json(obs.comments)
+
+        {
+          status_id: 0, # status_id not used with text values
+          status: obs.value_text,
+          timestamp: obs.obs_datetime,
+          updated_by: updated_by
+        }
+      end
+    end
+
+    # Helper to parse updated_by from obs comments field
+    def self.parse_comments_json(comments)
+      return {} if comments.blank?
+
+      JSON.parse(comments)
+    rescue JSON::ParserError
+      {}
+    end
   end
 end

data/app/services/lab/acknowledgement_service.rb

@@ -14,9 +14,12 @@ module Lab
                                         date_received: params[:date_received])
       end
 
-      def acknowledgements_pending_sync(batch_size)
-        Lab::LabAcknowledgement.where(pushed: false)
-                               .limit(batch_size)
+      def acknowledgements_pending_sync(batch_size, start_date: nil)
+        query = Lab::LabAcknowledgement.joins(:order).where(pushed: false)
+
+        query = query.where('orders.date_created >= ?', start_date) if start_date
+
+        query.limit(batch_size)
       end
 
       def push_acknowledgement(acknowledgement, lims_api)
@@ -30,7 +33,8 @@ module Lab
             Rails.logger.info("Updating acknowledgement ##{acknowledgement_dto[:tracking_number]} in LIMS")
             response = lims_api.acknowledge(acknowledgement_dto)
             Rails.logger.info("Info #{response}")
-            if ['results already delivered for test name given', 'test result acknowledged successfully', 'test result already acknowledged electronically at facility'].include?(response['message'])
+            if ['results already delivered for test name given', 'test result acknowledged successfully',
+                'test result already acknowledged electronically at facility'].include?(response['message'])
               acknowledgement.pushed = true
               acknowledgement.date_pushed = Time.now
               acknowledgement.save!

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

@@ -4,20 +4,22 @@ module Lab
   module Lims
     # This class is responsible for handling the acknowledgement of lab orders
     class AcknowledgementWorker
-      attr_reader :lims_api
+      attr_reader :lims_api, :start_date
 
       include Utils # for logger
 
       SECONDS_TO_WAIT_FOR_ORDERS = 30
 
-      def initialize(lims_api)
+      def initialize(lims_api, start_date: nil)
         @lims_api = lims_api
+        @start_date = start_date
       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
+          acknowledgements = Lab::AcknowledgementService.acknowledgements_pending_sync(batch_size,
+                                                                                       start_date: start_date).all
 
           logger.debug("Found #{acknowledgements.size} acknowledgements...")
           acknowledgements.each do |acknowledgement|