his_emr_api_lab 2.1.9.pre.alpha → 2.1.9.pre.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfef9418fc9d94d233f24d04883623d67e0c59c2aacea66bc15d3cca61192f78
-  data.tar.gz: 2d6324bf11f30c87398819042e3a0835275596961bfd838d088a63ae7a4f93c2
+  metadata.gz: c6c20f1ba07edd60ba5795eaaef1ca3f34395060b1f9ed0160a5513777d657d0
+  data.tar.gz: d16b695b3592233474fa9bbc2f90c85db7d04161a02f8107c56f92fd4e82a9fb
 SHA512:
-  metadata.gz: c7eaa989ae6027aaba3bcd29e90136d1f93eda66854f7ee5bf84453420e0c66a40a928e460e00ee48bdee3fac8e2de05b7c030a7c71c8d4a6bf9457704dc7c6f
-  data.tar.gz: 16048c52a25d2876d79d6b3526b13625c67de47c44717de48910f905a75bb02dbd1cd48d7ce22e8b58947e61a1cb603340ea3bbdb1cce7536bb1774f41a72d65
+  metadata.gz: 035cf4578ee6f60ba3406a66f88ea33cc54ea7d85ab38524b7e6ae54c9b4b80e03fe2938fc34d047e72df9423b71b8eba1f40004a8fd688555b56c3aebb81605
+  data.tar.gz: feda70dff8797923f46078a42429b274d7562eb5105a5d43c1d746f744436c6c516847aa2ef68d7b235f1d1a216981e10d4c707bc6f4fb45372d6b867c412a2a

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 'his_emr_api_lab', git: 'https://github.com/EGPAFMalawiHIS/HIS-EMR-API-Lab', branch: 'development'
+gem 'lab', git: 'https://github.com/EGPAFMalawiHIS/HIS-EMR-API-Lab', branch: 'development'
 ```
 
 And then execute:
 
 ```bash
-$ bundle install 
+$ bundle install lab
 ```
 
 Or install it yourself as:
 
 ```bash
-$ gem install his_emr_api_lab
+$ gem install lab
 ```
 
 Finally run:
 
 ```bash
-$ bundle exec rails his_emr_api_lab:install
+$ bundle exec rails lab:install
 ```
 
 ## Configuration
@@ -66,19 +66,6 @@ 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

@@ -52,8 +52,7 @@ module Lab
     end
 
     def order_status
-      order_params = params.permit(:tracking_number, :status, :status_time, :comments, :status_id,
-                                    updated_by: [:first_name, :last_name, :id, :phone_number])
+      order_params = params.permit(:tracking_number, :status, :status_time, :comments)
       OrdersService.update_order_status(order_params)
       render json: { message: "Status for order #{order_params['tracking_number']} successfully updated" }, status: :ok
     end

data/app/jobs/lab/process_lab_result_job.rb

@@ -7,8 +7,11 @@ 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,7 +10,8 @@ module Lab
       Rails.logger.info('Initialising LIMS REST API...')
 
       User.current = Lab::Lims::Utils.lab_user
-      Location.current = Location.find_by_name('ART clinic')
+      # Set location from patient's most recent encounter to ensure proper context
+      set_location_from_patient_encounter(patient_id)
 
       lockfile = Rails.root.join('tmp', "update-patient-orders-#{patient_id}.lock")
 
@@ -28,5 +29,53 @@ 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,10 +8,14 @@ module Lab
       Rails.logger.info("Voiding order ##{order_id} in LIMS")
 
       User.current = Lab::Lims::Utils.lab_user
-      Location.current = Location.find_by_name('ART clinic')
+      # 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')
 
       worker = Lab::Lims::PushWorker.new(Lab::Lims::ApiFactory.create_api)
-      worker.push_order(Lab::LabOrder.unscoped.find(order_id))
+      worker.push_order(order)
     end
   end
 end

data/app/models/lab/lab_order.rb

@@ -8,11 +8,6 @@ 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,
@@ -49,20 +44,12 @@ 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
 
@@ -70,13 +57,11 @@ module Lab
     scope :not_drawn, -> { where(concept_id: ConceptName.where(name: 'Unknown').select(:concept_id)) }
 
     def self.prefetch_relationships
-      # 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)
+      includes(:reason_for_test,
+               :requesting_clinician,
+               :target_lab,
+               :comment_to_fulfiller,
+               tests: [:result])
     end
   end
 end

data/app/models/lab/lab_result.rb

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

data/app/models/lab/lab_test.rb

@@ -6,33 +6,14 @@ 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,
-            -> { unscoped.where(voided: 0, concept_id: Lab::LabTest.test_result_concept_id) },
+            -> { where(concept: ConceptName.where(name: Lab::Metadata::TEST_RESULT_CONCEPT_NAME)) },
             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
+      super(reason)
     end
   end
 end

data/app/serializers/lab/lab_order_serializer.rb

@@ -9,7 +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
 
-      encounter = Encounter.find_by_encounter_id(order.encounter_id)
+      # 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)
 
       ActiveSupport::HashWithIndifferentAccess.new(
@@ -36,10 +37,8 @@ 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.result
+            result_obs = test.children.first
 
             {
               id: test.obs_id,
@@ -47,9 +46,7 @@ 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),
-              test_status: latest_test_status(test),
-              test_status_trail: serialize_test_status_trail(test)
+              result: result_obs && ResultSerializer.serialize(result_obs)
             }
           end
         }
@@ -78,72 +75,5 @@ 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/lims/api/rest_api.rb

@@ -77,82 +77,15 @@ module Lab
         def consume_orders(*_args, patient_id: nil, **_kwargs)
           orders_pending_updates(patient_id).each do |order|
             order_dto = Lab::Lims::OrderSerializer.serialize_order(order)
-
-            # Always fetch the full order from NLIMS to get status trails
-            begin
-              lims_order = find_lims_order(order.accession_number)
-              patch_order_dto_with_lims_order!(order_dto, lims_order)
-
-              Rails.logger.debug("NLIMS order structure for #{order.accession_number}:")
-              Rails.logger.debug("  Has 'order' key: #{lims_order.key?('order')}")
-              Rails.logger.debug("  Has 'data' key: #{lims_order.key?('data')}")
-              Rails.logger.debug("  Top level keys: #{lims_order.keys.inspect}")
-
-              # Also extract status trails from the NLIMS order
-              # Note: NLIMS might return order data under 'order' or 'data.order'
-              order_data = lims_order['order'] || lims_order.dig('data', 'order') || lims_order
-
-              if order_data && order_data['status_trail']
-                Rails.logger.info("Found #{order_data['status_trail'].size} order status trail entries from NLIMS")
-                order_dto[:sample_statuses] ||= []
-                # Convert NLIMS status trail to the format expected by PullWorker
-                # Note: sample_statuses must be an array of single-key hashes
-                order_data['status_trail'].each do |trail|
-                  # Convert ISO 8601 timestamp to YYYYMMDDHHmmss format
-                  timestamp_key = convert_timestamp_to_key(trail['timestamp'])
-                  order_dto[:sample_statuses] << {
-                    timestamp_key => {
-                      'status_id' => trail['status_id'],
-                      'status' => trail['status'],
-                      'updated_by' => trail['updated_by']
-                    }
-                  }
-                  Rails.logger.debug("  Added order status: #{trail['status']} at #{timestamp_key}")
-                end
-                Rails.logger.debug("Final sample_statuses: #{order_dto[:sample_statuses].inspect}")
-              else
-                Rails.logger.warn("No order status_trail found in NLIMS response for #{order.accession_number}")
-                Rails.logger.debug("Order data keys: #{order_data&.keys&.inspect}")
-              end
-
-              # Extract test status trails from NLIMS tests
-              tests_data = lims_order['tests'] || lims_order.dig('data', 'tests') || []
-              if tests_data.is_a?(Array)
-                Rails.logger.debug("Processing #{tests_data.size} tests from NLIMS")
-                order_dto['test_statuses'] ||= {}
-                tests_data.each do |test|
-                  next unless test['status_trail'].is_a?(Array)
-
-                  test_name = test.dig('test_type', 'name')
-                  next unless test_name
-
-                  Rails.logger.debug("  Found #{test['status_trail'].size} status trail entries for test #{test_name}")
-                  order_dto['test_statuses'][test_name] ||= {}
-                  test['status_trail'].each do |trail|
-                    # Convert ISO 8601 timestamp to YYYYMMDDHHmmss format
-                    timestamp_key = convert_timestamp_to_key(trail['timestamp'])
-                    order_dto['test_statuses'][test_name][timestamp_key] = {
-                      'status_id' => trail['status_id'],
-                      'status' => trail['status'],
-                      'updated_by' => trail['updated_by']
-                    }
-                  end
-                end
-              end
-            rescue RestClient::NotFound
-              Rails.logger.warn("Order ##{order.accession_number} not found in NLIMS, using local data only")
+            if order_dto['priority'].nil? || order_dto['sample_type'].casecmp?('not_specified')
+              patch_order_dto_with_lims_order!(order_dto, find_lims_order(order.accession_number))
             end
-
-            # Try to fetch results if available
             if order_dto['test_results'].empty?
               begin
                 patch_order_dto_with_lims_results!(order_dto, find_lims_results(order.accession_number))
-              rescue InvalidParameters => e
-                Rails.logger.info("No results available for ##{order.accession_number}: #{e.message}")
-                # Don't skip - continue processing to save status trails
-              rescue RestClient::NotFound
-                Rails.logger.info("No results found for ##{order.accession_number}")
-                # Don't skip - continue processing to save status trails
+              rescue InvalidParameters => e # LIMS responds with a 401 when a result is not found :(
+                Rails.logger.error("Failed to fetch results for ##{order.accession_number}: #{e.message}")
+                next
               end
             end
 
@@ -294,7 +227,7 @@ module Lab
           {
             order: {
               tracking_number: order_dto.fetch(:tracking_number),
-              district: current_district,
+              district: order_dto.fetch(:districy),
               health_facility_name: order_dto.fetch(:sending_facility),
               sending_facility: order_dto.fetch(:sending_facility),
               arv_number: order_dto.fetch(:patient).fetch(:arv_number),
@@ -348,24 +281,17 @@ module Lab
             status: 'specimen_collected',
             time_updated: date_updated,
             sample_type: order_dto.fetch(:sample_type_map),
-            updated_by: status.fetch(:updated_by)
+            updated_by: status.fetch(:updated_by),
+            status_trail: [
+              updated_by: {
+                first_name: status.fetch(:updated_by).fetch(:first_name),
+                last_name: status.fetch(:updated_by).fetch(:last_name),
+                id_number: status.fetch(:updated_by).fetch(:id)
+              }
+            ]
           }
         end
 
-        def current_district
-          health_centre = Location.current_health_center
-          raise 'Current health centre not set' unless health_centre
-
-          district = health_centre.district || Lab::Lims::Config.application['district']
-
-          unless district
-            health_centre_name = "##{health_centre.id} - #{health_centre.name}"
-            raise "Current health centre district not set: #{health_centre_name}"
-          end
-
-          district
-        end
-
         ##
         # Extracts sample drawn status from an OrderDto
         def sample_drawn_status(order_dto)
@@ -511,23 +437,25 @@ module Lab
           order_dto['test_results'].each do |test_name, results|
             Rails.logger.info("Pushing result for order ##{order_dto['tracking_number']}")
             in_authenticated_session do |headers|
-              params = make_update_test_params(order_dto['tracking_number'], test_name, results)
+              params = make_update_test_params(order_dto, test_name, results)
 
-              RestClient.post(expand_uri("tests/#{order_dto['tracking_number']}", api_version: 'v2'), params, headers)
+              RestClient.put(expand_uri("tests/#{order_dto['tracking_number']}", api_version: 'v2'), params, headers)
             end
           end
         end
 
-        def make_update_test_params(_tracking_number, test, results, test_status = 'Drawn')
+        def make_update_test_params(order_dto, test, results, test_status = 'Drawn')
+          # Find the concept from the test name (which is a string)
+          concept = ::ConceptName.find_by(name: test)&.concept
           {
             test_status:,
             time_updated: results['result_date'],
             test_type: {
-              name: ::Concept.find(test.concept_id).test_catalogue_name,
-              nlims_code: ::Concept.find(test.concept_id).nlims_code
+              name: concept&.test_catalogue_name,
+              nlims_code: concept&.nlims_code
             },
-            test_results: results['results'].map do |measure, _value|
-              measure_name, measure_value = measure
+            test_results: results['results'].map do |measure_name, value|
+              measure_value = value['result_value']
               {
                 measure: {
                   name: measure_name,
@@ -539,6 +467,18 @@ module Lab
                   result_date: results['result_date']
                 }
               }
+            end,
+            status_trail: order_dto['sample_statuses'].map do |trail_entry|
+              date, status = trail_entry.each_pair.first
+              {
+                status: status['status'],
+                timestamp: date,
+                updated_by: {
+                  first_name: status.fetch('updated_by').fetch('first_name'),
+                  last_name: status.fetch('updated_by').fetch('last_name'),
+                  id_number: status.fetch('updated_by').fetch('id')
+                }
+              }
             end
           }
         end
@@ -617,20 +557,6 @@ module Lab
 
           orders
         end
-
-        # Converts ISO 8601 timestamp to YYYYMMDDHHmmss format
-        def convert_timestamp_to_key(timestamp)
-          return timestamp if timestamp.nil? || timestamp.empty?
-
-          begin
-            # Parse ISO 8601 timestamp and format as YYYYMMDDHHmmss
-            Time.parse(timestamp).strftime('%Y%m%d%H%M%S')
-          rescue StandardError => e
-            Rails.logger.warn("Failed to parse timestamp '#{timestamp}': #{e.message}")
-            # Fallback: remove all non-digits
-            timestamp.to_s.gsub(/\D/, '')
-          end
-        end
       end
     end
   end
@@ -759,7 +685,7 @@ module Lab
   def make_create_params(order_dto)
     {
       tracking_number: order_dto.fetch(:tracking_number),
-      district: current_district,
+      district: order_dto.fetch(:districy),
       health_facility_name: order_dto.fetch(:sending_facility),
       first_name: order_dto.fetch(:patient).fetch(:first_name),
       last_name: order_dto.fetch(:patient).fetch(:last_name),
@@ -797,20 +723,6 @@ module Lab
     }
   end
 
-  def current_district
-    health_centre = Location.current_health_center
-    raise 'Current health centre not set' unless health_centre
-
-    district = health_centre.district || Lab::Lims::Config.application['district']
-
-    unless district
-      health_centre_name = "##{health_centre.id} - #{health_centre.name}"
-      raise "Current health centre district not set: #{health_centre_name}"
-    end
-
-    district
-  end
-
   ##
   # Extracts sample drawn status from an OrderDto
   def sample_drawn_status(order_dto)