his_emr_api_lab 2.4.1 → 2.4.2.pre.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 991f9ab4aaf486c50137bd472f03d80b8ab12d09a01a020fa0d5f2cd469bc771
-  data.tar.gz: 617e5482ada6f17c4daaef81e884b5496f04fb39b8fa0cb60be2b66aaf391612
+  metadata.gz: 4c709c42cf59eed483429321c58ddf08678dc809850c2d59cb58ca8d8bf4f3c3
+  data.tar.gz: 3f54225c34b8547665dfa5d553971e7d0b299d6744496d9e457184f3c7c105b8
 SHA512:
-  metadata.gz: 9a8ffca6167d119463b70f17b76576aa843b7015f0fc9ae8d4f252f0a249089c07e4acb731e7d7ac657235bb7ff8f4674cbe3a99888f863eff6ad7d7764ad537
-  data.tar.gz: 41d6799ca76f3727c87f70836417564a1459a7f327d5576ffe115d696bd111f04f756d702ed00122d16b40e26d4bb070fc66d8bf4eefdc35aff69625f1633e30
+  metadata.gz: c53d18764e2dd4d99e4881855778acec6c8a2852744eb8bba144aea85249d8a0d5555f6c6e85773333367439606fa8652104d14169cb0290964bd308c23f5e7a
+  data.tar.gz: 45a1847d5591bbd4e352d15d320651cbaa2b2d774b5752cc17caceb8416a3fa56c505efd230b3c4635bb334c4d2bd3d2e885de5996324e94da1f5a82d01260c6

data/app/models/lab/lab_result.rb

@@ -16,8 +16,9 @@ module Lab
 
     belongs_to :test,
                (lambda do
-                  where(concept: ConceptName.where(name: Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
-                                            .select(:concept_id))
+                  unscope(where: :location_id)
+                    .where(concept: ConceptName.where(name: Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
+                                               .select(:concept_id))
                 end),
                class_name: 'Observation',
                foreign_key: :obs_group_id

data/app/serializers/lab/lab_order_serializer.rb

@@ -1,15 +1,21 @@
 # frozen_string_literal: true
 
+require_relative '../../services/lab/order_location_resolver'
+
 module Lab
   module LabOrderSerializer
     def self.serialize_order(order, tests: nil, requesting_clinician: nil, reason_for_test: nil, target_lab: nil, comment_to_fulfiller: nil)
-      tests ||= order.voided == 1 ? voided_tests(order) : order.tests
-      requesting_clinician ||= order.requesting_clinician
-      comment_to_fulfiller ||= order.comment_to_fulfiller
-      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)
+      tests ||= [1, true].include?(order.voided) ? voided_tests(order) : order_tests(order)
+      requesting_clinician ||= order_observation(order, Lab::Metadata::REQUESTING_CLINICIAN_CONCEPT_NAME)
+      comment_to_fulfiller ||= order_observation(order, Lab::Metadata::COMMENT_TO_FULFILLER_CONCEPT_NAME)
+      reason_for_test ||= order_observation(order, Lab::Metadata::REASON_FOR_TEST_CONCEPT_NAME)
+
+      encounter = Encounter.unscoped.find_by_encounter_id(order.encounter_id)
+      location = Lab::OrderLocationResolver.location_for_order(order, fallback_location_id: encounter&.location_id)
+      target_lab = target_lab&.value_text ||
+                   order_observation(order, Lab::Metadata::TARGET_LAB_CONCEPT_NAME)&.value_text ||
+                   location&.name ||
+                   Location.current_health_center&.name
       program = Program.find_by_program_id(encounter&.program_id)
 
       ActiveSupport::HashWithIndifferentAccess.new(
@@ -20,7 +26,7 @@ module Lab
           encounter_id: order.encounter_id,
           **(Encounter.column_names.include?('visit_id') ? { visit_id: encounter&.visit_id } : {}),
           order_date: order.start_date,
-          location_id: encounter&.location_id,
+          location_id: location&.location_id,
           program_id: encounter&.program_id,
           program_name: program&.name,
           patient_id: order.patient_id,
@@ -59,8 +65,10 @@ module Lab
 
     def self.test_method(order, _concept_id)
       obs = ::Observation
+            .unscoped
             .select(:value_coded)
-            .where(concept_id: ConceptName.find_by_name(Metadata::TEST_METHOD_CONCEPT_NAME).concept_id, order_id: order.id)
+            .where(concept_id: ConceptName.find_by_name(Metadata::TEST_METHOD_CONCEPT_NAME).concept_id, order_id: order.order_id)
+            .where(voided: 0)
             .first
       {
         concept_id: obs&.value_coded,
@@ -75,10 +83,25 @@ module Lab
         ::ConceptName.find_by_concept_id(concept_id)&.name
     end
 
+    def self.order_tests(order)
+      concept = ConceptName.where(name: Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
+                           .select(:concept_id)
+      LabTest.unscoped.where(concept_id: concept, order_id: order.order_id, voided: 0)
+             .order(:date_created, :obs_id)
+    end
+
     def self.voided_tests(order)
       concept = ConceptName.where(name: Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
                            .select(:concept_id)
-      LabTest.unscoped.where(concept:, order:, voided: true)
+      LabTest.unscoped.where(concept_id: concept, order_id: order.order_id, voided: 1)
+             .order(:date_voided, :obs_id)
+    end
+
+    def self.order_observation(order, concept_name)
+      concept = ConceptName.where(name: concept_name).select(:concept_id)
+      Observation.unscoped.where(order_id: order.order_id, concept_id: concept, voided: 0)
+                 .order(:date_created, :obs_id)
+                 .first
     end
 
     def self.latest_order_status(order)

data/app/serializers/lab/result_serializer.rb

@@ -11,8 +11,8 @@ module Lab
         concept_name = get_test_catalog_concept_name(measure.concept_id)
         program_id = ''
         if measure.obs_id.present?
-          obs = Observation.unscope(where: :obs_group_id).find_by(obs_id: measure.obs_id)
-          encounter = Encounter.find_by(encounter_id: obs&.encounter_id)
+          obs = Observation.unscoped.find_by(obs_id: measure.obs_id)
+          encounter = Encounter.unscoped.find_by(encounter_id: obs&.encounter_id)
           program_id = encounter&.program_id
         end
 

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

@@ -19,11 +19,12 @@ module Lab
         def create_order(order_dto)
           response = in_authenticated_session do |headers|
             Rails.logger.info("Pushing order ##{order_dto[:tracking_number]} to LIMS")
+            payload = make_create_params(order_dto)
             if order_dto['sample_type'].casecmp?('not_specified')
-              RestClient.post(expand_uri('orders/requests', api_version: 'v2'), make_create_params(order_dto),
-                              headers)
+              RestClient.post(expand_uri('orders/requests', api_version: 'v2'), payload.to_json,
+                              json_headers(headers))
             else
-              RestClient.post(expand_uri('orders', api_version: 'v2'), make_create_params(order_dto), headers)
+              RestClient.post(expand_uri('orders', api_version: 'v2'), payload.to_json, json_headers(headers))
             end
           end
 
@@ -54,7 +55,7 @@ module Lab
                               date_acknowledged: acknowledgement_dto[:date_acknowledged],
                               recipient_type: acknowledgement_dto[:recipient_type],
                               acknowledged_by: 'emr_at_facility'
-                            }, headers)
+                            }.to_json, json_headers(headers))
           end
           Rails.logger.info("Acknowledged order ##{acknowledgement_dto} in LIMS. Response: #{response}")
           JSON.parse(response)
@@ -66,7 +67,7 @@ module Lab
         def update_order(_id, order_dto)
           in_authenticated_session do |headers|
             RestClient.put(expand_uri("orders/#{order_dto[:tracking_number]}", api_version: 'v2'),
-                           make_update_params(order_dto), headers)
+                           make_update_params(order_dto).to_json, json_headers(headers))
           end
 
           update_order_results(order_dto)
@@ -176,7 +177,8 @@ module Lab
             in_authenticated_session do |headers|
               date_voided, voided_status = find_test_status(order_dto, test.name, 'Voided')
               params = make_void_test_params(tracking_number, test, voided_status['updated_by'], date_voided)
-              RestClient.put(expand_uri("tests/#{tracking_number}", api_version: 'v2'), params.to_json, headers)
+              RestClient.put(expand_uri("tests/#{tracking_number}", api_version: 'v2'), params.to_json,
+                             json_headers(headers))
             end
           end
         end
@@ -277,6 +279,10 @@ module Lab
           raise InvalidParameters, body['message']
         end
 
+        def json_headers(headers)
+          headers.merge('Content-Type' => 'application/json', 'Accept' => 'application/json')
+        end
+
         ##
         # Takes a LIMS API relative URI and converts it to a full URL.
         def expand_uri(uri, api_version: 'v1')
@@ -328,18 +334,33 @@ module Lab
               date_of_birth: order_dto.fetch(:patient).fetch(:dob)
             },
             tests: order_dto.fetch(:tests_map).map do |test|
-              concept = ::Concept.find(test.concept_id)
+              concept = test_type_concept(test)
               {
                 test_type: {
                   name: concept.test_catalogue_name,
                   nlims_code: concept.nlims_code,
                   method_of_testing: test&.test_method&.name
-                }
+                }.compact
               }
             end
           }
         end
 
+        def test_type_concept(test)
+          concept = ::Concept.find(test.concept_id)
+          return concept if concept.nlims_code.to_s.match?(/\ANLIMS_TT_/)
+
+          parent_test_types = ConceptSet.where(concept_id: concept.concept_id).filter_map do |concept_set|
+            parent = ::Concept.find_by(concept_id: concept_set.concept_set)
+            parent if parent&.nlims_code.to_s.match?(/\ANLIMS_TT_/)
+          end.uniq(&:concept_id)
+
+          return parent_test_types.first if parent_test_types.one?
+
+          Rails.logger.warn("Could not resolve test type for concept ##{concept.concept_id} (#{concept.test_catalogue_name})")
+          concept
+        end
+
         ##
         # Converts an OrderDto to parameters for POST /update_order
         def make_update_params(order_dto)
@@ -506,7 +527,8 @@ module Lab
             in_authenticated_session do |headers|
               params = make_update_test_params(order_dto, test_name, results)
 
-              RestClient.put(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.to_json,
+                             json_headers(headers))
             end
           end
         end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'exceptions'
+require_relative '../order_location_resolver'
 
 module Lab
   module Lims
@@ -12,10 +13,13 @@ module Lab
       ##
       # Unpacks a LIMS order into an object that OrdersService can handle
       def to_order_service_params(patient_id:)
+        location = Lab::OrderLocationResolver.location_from_name(facility_name(self['sending_facility'])) ||
+                   Lab::OrderLocationResolver.location_from_name(self['order_location'])
         ActiveSupport::HashWithIndifferentAccess.new(
           program_id: lab_program.program_id,
           accession_number: self['tracking_number'],
           patient_id:,
+          location_id: location&.location_id,
           specimen: { concept_id: specimen_type_id },
           tests: self['tests_map']&.map { |test| { concept_id: test.concept_id } },
           requesting_clinician:,

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

@@ -3,6 +3,7 @@
 require_relative 'config'
 require_relative 'order_dto'
 require_relative 'utils'
+require_relative '../order_location_resolver'
 
 module Lab
   module Lims
@@ -46,21 +47,7 @@ module Lab
         private
 
         def get_location(location_id, order)
-          # Try to get location from the location_id first
-          location = Location.find_by(location_id: location_id) if location_id.present?
-
-          # Fallback to current health center
-          location ||= Location.current_health_center
-
-          # Last fallback: try to get from order's observation encounter
-          # Use unscoped to find observations/encounters across all locations
-          if location.nil? && order.present?
-            obs = Observation.unscoped.find_by(order_id: order.order_id)
-            if obs.respond_to?(:encounter) && obs.encounter.respond_to?(:location)
-              encounter = Encounter.unscoped.find_by(encounter_id: obs.encounter_id)
-              location = encounter&.location
-            end
-          end
+          location = Lab::OrderLocationResolver.location_for_order(order, fallback_location_id: location_id)
 
           raise 'Current health center not set' unless location
 
@@ -161,7 +148,7 @@ module Lab
         end
 
         def format_test_status_trail(order)
-          tests = [0, false].include?(order.voided) ? order.tests : Lab::LabOrderSerializer.voided_tests(order)
+          tests = [0, false].include?(order.voided) ? Lab::LabOrderSerializer.order_tests(order) : Lab::LabOrderSerializer.voided_tests(order)
           tests.each_with_object({}) do |test, trail|
             test_name = format_test_name(::Concept.find(test.value_coded).test_catalogue_name)
 

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../order_location_resolver'
+
 module Lab
   module Lims
     ##
@@ -191,7 +193,9 @@ module Lab
 
       def create_order(patient, order_dto)
         logger.debug("Creating order ##{order_dto['_id']}")
-        order = OrdersService.order_test(order_dto.to_order_service_params(patient_id: patient.patient_id))
+        params = order_dto.to_order_service_params(patient_id: patient.patient_id)
+        params[:location_id] ||= location_id_for_order_dto(order_dto)
+        order = OrdersService.order_test(params)
 
         # Extract and save status trails from NLIMS
         save_status_trails_from_nlims(order, order_dto)
@@ -204,8 +208,9 @@ module Lab
 
       def update_order(patient, order_id, order_dto)
         logger.debug("Updating order ##{order_dto['_id']}")
-        order = OrdersService.update_order(order_id, order_dto.to_order_service_params(patient_id: patient.patient_id)
-                                                              .merge(force_update: 'true'))
+        params = order_dto.to_order_service_params(patient_id: patient.patient_id)
+        params[:location_id] ||= Lab::OrderLocationResolver.location_id_for_order_id(order_id, facility_name: order_dto[:sending_facility])
+        order = OrdersService.update_order(order_id, params.merge(force_update: 'true'))
 
         # Extract and save status trails from NLIMS
         save_status_trails_from_nlims(order, order_dto)
@@ -245,6 +250,7 @@ module Lab
           ResultsService.create_results(test.id, { provider_id: User.current.person_id,
                                                    date: Utils.parse_date(test_results['result_date'] || result_date,
                                                                           order[:order_date].to_s),
+                                                   location_id: Lab::OrderLocationResolver.location_id_for_test(test),
                                                    comments: "LIMS import: Entered by: #{creator}",
                                                    measures: })
         end
@@ -255,7 +261,13 @@ module Lab
         test_concept = Utils.find_concept_by_name(test_name)
         raise "Unknown test name, #{test_name}!" unless test_concept
 
-        LabTest.find_by(order_id:, value_coded: test_concept.concept_id)
+        LabTest.unscoped.find_by(order_id:, value_coded: test_concept.concept_id, voided: 0)
+      end
+
+      def location_id_for_order_dto(order_dto)
+        local_order = Lab::LabOrder.unscoped.find_by(accession_number: order_dto[:tracking_number])
+
+        Lab::OrderLocationResolver.location_id_for_order(local_order, facility_name: order_dto[:sending_facility])
       end
 
       def find_measure(_order, indicator_name, value)
@@ -342,6 +354,7 @@ module Lab
           logger.error("Order not found: #{order_id}")
           return
         end
+        location_id = Lab::OrderLocationResolver.location_id_for_order(lab_order)
 
         # sample_statuses is an array of single-key hashes like:
         # [{ "20260225120000" => { "status" => "Drawn", ... } }, { "20260225130000" => { ... } }]
@@ -383,6 +396,7 @@ module Lab
                 obs_datetime: timestamp,
                 comments: updated_by.to_json,
                 creator: User.current&.user_id || 1,
+                location_id:,
                 date_created: Time.now,
                 uuid: SecureRandom.uuid
               )
@@ -412,8 +426,9 @@ module Lab
           test_concept = Utils.find_concept_by_name(Utils.translate_test_name(test_name))
           next unless test_concept
 
-          test = Lab::LabTest.find_by(order_id: order['order_id'], value_coded: test_concept.concept_id)
+          test = Lab::LabTest.unscoped.find_by(order_id: order['order_id'], value_coded: test_concept.concept_id, voided: 0)
           next unless test
+          location_id = Lab::OrderLocationResolver.location_id_for_test(test)
 
           # Process each status in the trail
           statuses.each do |timestamp_key, status_data|
@@ -449,6 +464,7 @@ module Lab
                 obs_datetime: timestamp,
                 comments: updated_by.to_json,
                 creator: User.current&.user_id || 1,
+                location_id:,
                 date_created: Time.now,
                 uuid: SecureRandom.uuid
               )

data/app/services/lab/order_location_resolver.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative 'metadata'
+
+module Lab
+  # Resolves the location that should be used for lab sync records.
+  #
+  # LIMS workers often run as lab_daemon, whose current location can differ from
+  # the clinician/order location. Order-linked observations are the most reliable
+  # source because they carry the location where the order was created.
+  module OrderLocationResolver
+    ORDER_OBSERVATION_CONCEPT_NAMES = [
+      Lab::Metadata::TEST_TYPE_CONCEPT_NAME,
+      Lab::Metadata::TEST_METHOD_CONCEPT_NAME,
+      Lab::Metadata::REQUESTING_CLINICIAN_CONCEPT_NAME,
+      Lab::Metadata::REASON_FOR_TEST_CONCEPT_NAME,
+      Lab::Metadata::TARGET_LAB_CONCEPT_NAME,
+      Lab::Metadata::COMMENT_TO_FULFILLER_CONCEPT_NAME
+    ].freeze
+
+    module_function
+
+    def location_for_order(order, fallback_location_id: nil, facility_name: nil)
+      observation_location_for_order(order) ||
+        location_by_id(fallback_location_id || record_location_id(order)) ||
+        encounter_location_for_order(order) ||
+        creator_location_for_order(order) ||
+        location_from_name(facility_name) ||
+        Location.current_health_center
+    end
+
+    def location_id_for_order(order, fallback_location_id: nil, facility_name: nil)
+      location_for_order(order, fallback_location_id:, facility_name:)&.location_id
+    end
+
+    def location_for_order_id(order_id, fallback_location_id: nil, facility_name: nil)
+      order = Lab::LabOrder.unscoped.find_by(order_id:)
+
+      location_for_order(order, fallback_location_id:, facility_name:)
+    end
+
+    def location_id_for_order_id(order_id, fallback_location_id: nil, facility_name: nil)
+      location_for_order_id(order_id, fallback_location_id:, facility_name:)&.location_id
+    end
+
+    def location_for_test(test)
+      location_for_order_id(record_order_id(test), fallback_location_id: record_location_id(test)) ||
+        location_by_id(record_location_id(test)) ||
+        location_by_id(encounter_location_id_for_record(test))
+    end
+
+    def location_id_for_test(test)
+      location_for_test(test)&.location_id
+    end
+
+    def location_from_name(name)
+      name = name.to_s.strip
+      return nil if name.blank? || name.casecmp?('Unknown') || name.casecmp?('not_assigned')
+
+      Location.unscoped.where('LOWER(name) = ?', name.downcase).first
+    end
+
+    def location_by_id(location_id)
+      return nil if location_id.blank? || location_id.to_i.zero?
+
+      Location.unscoped.find_by(location_id:)
+    end
+
+    def observation_location_for_order(order)
+      order_id = record_order_id(order)
+      return nil if order_id.blank?
+
+      location_id = prioritized_order_observations(order_id).first&.location_id
+      location_by_id(location_id)
+    end
+
+    def encounter_location_for_order(order)
+      location_by_id(encounter_location_id_for_record(order))
+    end
+
+    def creator_location_for_order(order)
+      creator_id = record_creator_id(order)
+      return nil if creator_id.blank?
+
+      user = User.unscoped.find_by(user_id: creator_id)
+      location_by_id(user&.location_id)
+    end
+
+    def prioritized_order_observations(order_id)
+      scope = Observation.unscoped.where(order_id:, voided: 0).where.not(location_id: [nil, 0])
+      concept_ids = order_location_concept_ids
+      return scope.order(:date_created, :obs_id) if concept_ids.blank?
+
+      quoted_ids = concept_ids.map(&:to_i).join(',')
+      scope.order(Arel.sql("CASE WHEN concept_id IN (#{quoted_ids}) THEN 0 ELSE 1 END, date_created ASC, obs_id ASC"))
+    end
+
+    def order_location_concept_ids
+      ConceptName.where(name: ORDER_OBSERVATION_CONCEPT_NAMES).pluck(:concept_id)
+    end
+
+    def encounter_location_id_for_record(record)
+      encounter_id = record_encounter_id(record)
+      return nil if encounter_id.blank?
+
+      Encounter.unscoped.find_by(encounter_id:)&.location_id
+    end
+
+    def record_order_id(record)
+      return nil unless record
+      return record.order_id if record.respond_to?(:order_id)
+
+      value_from_hash(record, :order_id) || value_from_hash(record, :id)
+    end
+
+    def record_encounter_id(record)
+      return nil unless record
+      return record.encounter_id if record.respond_to?(:encounter_id)
+
+      value_from_hash(record, :encounter_id)
+    end
+
+    def record_location_id(record)
+      return nil unless record
+      return record.location_id if record.respond_to?(:location_id)
+
+      value_from_hash(record, :location_id)
+    end
+
+    def record_creator_id(record)
+      return nil unless record
+      return record.creator if record.respond_to?(:creator)
+
+      value_from_hash(record, :creator)
+    end
+
+    def value_from_hash(record, key)
+      return nil unless record.respond_to?(:[])
+
+      record[key] || record[key.to_s]
+    end
+  end
+end

data/app/services/lab/orders_service.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'order_location_resolver'
+
 module Lab
   ##
   # Manage lab orders.
@@ -163,6 +165,7 @@ module Lab
         # find the order
         order = find_order(order_params['tracking_number'])
         concept = ConceptName.find_by_name Lab::Metadata::LAB_ORDER_STATUS_CONCEPT_NAME
+        location_id = Lab::OrderLocationResolver.location_id_for_order(order)
         ActiveRecord::Base.transaction do
           void_order_status(order, concept)
           Observation.create!(
@@ -172,7 +175,8 @@ module Lab
             order_id: order.id,
             obs_datetime: order_params['status_time'] || Time.now,
             value_text: order_params['status'],
-            creator: User.current.id
+            creator: User.current.id,
+            location_id:
           )
 
           # Save order status trail if available
@@ -312,9 +316,14 @@ module Lab
         encounter_id = order_params[:encounter_id] || order_params[:encounter]
         patient_id = order_params[:patient_id] || order_params[:patient]
         visit = order_params[:visit]
+        location_id = location_id_from_order_params(order_params)
 
-        return Encounter.find(encounter_id) if order_params[:encounter] || order_params[:encounter_id]
-        raise StandardError, 'encounter_id|uuid or patient_id|uuid required' unless order_params[:patient]
+        if order_params[:encounter] || order_params[:encounter_id]
+          encounter = Encounter.unscoped.find(encounter_id)
+          encounter.update!(location_id:) if location_id.present? && encounter.respond_to?(:location_id) && encounter.location_id.blank?
+          return encounter
+        end
+        raise StandardError, 'encounter_id|uuid or patient_id|uuid required' unless patient_id
 
         encounter = Encounter.new
         encounter.patient = Patient.find(patient_id)
@@ -325,6 +334,7 @@ module Lab
         if Encounter.column_names.include?('program_id') && order_params[:program_id].present?
           encounter.program_id = order_params[:program_id]
         end
+        encounter.location_id = location_id if Encounter.column_names.include?('location_id') && location_id.present?
         encounter.save!
         encounter.reload
       end
@@ -433,6 +443,7 @@ module Lab
         # Use unscoped to find user regardless of location context
         creator = User.unscoped.find_by(username: 'lab_daemon')
         User.current ||= creator
+        values[:location_id] ||= Lab::OrderLocationResolver.location_id_for_order(order)
         Observation.create!(
           order:,
           encounter_id: order.encounter_id,
@@ -454,25 +465,42 @@ module Lab
       def update_reason_for_test(order, concept_id, force_update: false)
         raise InvalidParameterError, "Reason for test can't be blank" if concept_id.blank?
 
-        return if order.reason_for_test&.value_coded == concept_id
+        current_reason_for_test = order_observation(order, Lab::Metadata::REASON_FOR_TEST_CONCEPT_NAME)
+        return if current_reason_for_test&.value_coded == concept_id
 
-        if order.reason_for_test&.value_coded && !force_update
+        if current_reason_for_test&.value_coded && !force_update
           raise InvalidParameterError,
                 "Can't change reason for test once set"
         end
 
-        order.reason_for_test&.delete
+        current_reason_for_test&.delete
         date = order.start_date if order.respond_to?(:start_date)
         date ||= order.date_created
         add_reason_for_test(order, date: date, reason_for_test_id: concept_id)
       end
 
       def void_order_status(order, concept)
-        Observation.where(order_id: order.id, concept_id: concept.concept_id).each do |obs|
+        Observation.unscoped.where(order_id: order.id, concept_id: concept.concept_id).each do |obs|
           obs.void('New Status Received from LIMS')
         end
       end
 
+      def location_id_from_order_params(order_params)
+        order_params[:location_id] ||
+          order_params[:order_location_id] ||
+          Lab::OrderLocationResolver.location_from_name(order_params[:order_location])&.location_id ||
+          Lab::OrderLocationResolver.location_from_name(order_params['order_location'])&.location_id ||
+          Lab::OrderLocationResolver.location_from_name(order_params[:target_lab])&.location_id ||
+          Lab::OrderLocationResolver.location_from_name(order_params['target_lab'])&.location_id
+      end
+
+      def order_observation(order, concept_name)
+        concept = ConceptName.where(name: concept_name).select(:concept_id)
+        Observation.unscoped.where(order_id: order.order_id, concept_id: concept, voided: 0)
+                   .order(:date_created, :obs_id)
+                   .first
+      end
+
       def create_initial_order_status_trail(order)
         create_order_status_observation(
           order: order,
@@ -525,8 +553,8 @@ module Lab
           concept = Lab::Lims::Utils.find_concept_by_name(test_name)
           next unless concept
 
-          # Find the test observation
-          test = order.tests.find_by(value_coded: concept.concept_id)
+          # Find the test observation without the daemon's current-location scope.
+          test = Lab::LabTest.unscoped.find_by(order_id: order.order_id, value_coded: concept.concept_id, voided: 0)
           next unless test
 
           # Save each status trail entry
@@ -561,6 +589,8 @@ module Lab
           voided: 0
         )
 
+        location_id = Lab::OrderLocationResolver.location_id_for_order(order)
+
         # Create status observation
         Observation.create!(
           person_id: order.patient_id,
@@ -571,6 +601,7 @@ module Lab
           obs_datetime: timestamp,
           comments: updated_by.to_json,
           creator: User.current&.user_id || 1,
+          location_id:,
           date_created: Time.now,
           uuid: SecureRandom.uuid
         )
@@ -599,6 +630,8 @@ module Lab
           voided: 0
         )
 
+        location_id = Lab::OrderLocationResolver.location_id_for_test(test)
+
         # Create status observation
         Observation.create!(
           person_id: test.person_id,
@@ -609,6 +642,7 @@ module Lab
           obs_datetime: timestamp,
           comments: updated_by.to_json,
           creator: User.current&.user_id || 1,
+          location_id:,
           date_created: Time.now,
           uuid: SecureRandom.uuid
         )

data/app/services/lab/results_service.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'order_location_resolver'
+
 module Lab
   module ResultsService
     class << self
@@ -20,16 +22,15 @@ module Lab
         serializer = {}
         results_obs = {}
         ActiveRecord::Base.transaction do
-          test = begin
-            Lab::LabTest.find(test_id)
-          rescue StandardError
-            nil
-          end
-          test = Lab::LabTest.find_by_uuid(test_id) if test.blank?
+          test = Lab::LabTest.unscoped.find_by(obs_id: test_id)
+          test ||= Lab::LabTest.unscoped.find_by(uuid: test_id)
+          raise ActiveRecord::RecordNotFound, "Couldn't find Lab::LabTest with id=#{test_id}" unless test
+
           encounter = find_encounter(test, encounter_id: params[:encounter_id],
                                            encounter_uuid: params[:encounter],
                                            date: params[:date]&.to_date,
-                                           provider_id: params[:provider_id])
+                                           provider_id: params[:provider_id],
+                                           location_id: params[:location_id])
 
           results_obs = create_results_obs(encounter, test, params[:date], params[:comments])
           params[:measures].map { |measure| add_measure_to_results(results_obs, measure, params[:date]) }
@@ -105,22 +106,25 @@ module Lab
                          .first&.identifier
       end
 
-      def find_encounter(test, encounter_id: nil, encounter_uuid: nil, date: nil, provider_id: nil)
-        return Encounter.find(encounter_id) if encounter_id
-        return Encounter.find_by_uuid(encounter_uuid) if encounter_uuid
+      def find_encounter(test, encounter_id: nil, encounter_uuid: nil, date: nil, provider_id: nil, location_id: nil)
+        return Encounter.unscoped.find(encounter_id) if encounter_id
+        return Encounter.unscoped.find_by_uuid(encounter_uuid) if encounter_uuid
 
         lab_encounter_type = EncounterType.find_by_name!(Lab::Metadata::ENCOUNTER_TYPE_NAME)
+        source_encounter = Encounter.unscoped.find_by(encounter_id: test.encounter_id)
+        location_id ||= Lab::OrderLocationResolver.location_id_for_test(test)
 
         encounter = Encounter.new
         encounter.patient_id = test.person_id
-        encounter.program_id = test.encounter.program_id if Encounter.column_names.include?('program_id')
-        encounter.visit_id = test.encounter.visit_id if Encounter.column_names.include?('visit_id')
+        encounter.program_id = source_encounter&.program_id if Encounter.column_names.include?('program_id')
+        encounter.visit_id = source_encounter&.visit_id if Encounter.column_names.include?('visit_id')
         # Use bracket notation to set the encounter_type column directly (bypasses association)
         # This handles both Integer and EncounterType object
         encounter_type_value = lab_encounter_type.is_a?(Integer) ? lab_encounter_type : lab_encounter_type.encounter_type_id
         encounter[:encounter_type] = encounter_type_value
         encounter.encounter_datetime = date || Date.today
         encounter.provider_id = provider_id || User.current.user_id if Encounter.column_names.include?('provider_id')
+        encounter.location_id = location_id if Encounter.column_names.include?('location_id') && location_id.present?
         encounter.save!
         encounter.reload
         encounter
@@ -130,20 +134,23 @@ module Lab
       def create_results_obs(encounter, test, date, comments = nil)
         void_existing_results_obs(encounter, test)
         Lab::LabResult.create!(
+          test:,
           person_id: encounter.patient_id,
           encounter_id: encounter.encounter_id,
           concept_id: test_result_concept.concept_id,
           order_id: test.order_id,
           obs_group_id: test.obs_id,
+          location_id: encounter.location_id || Lab::OrderLocationResolver.location_id_for_test(test),
           obs_datetime: date&.to_datetime || DateTime.now,
           comments:
         )
       end
 
       def void_existing_results_obs(encounter, test)
-        result = Lab::LabResult.find_by(person_id: encounter.patient_id,
-                                        concept_id: test_result_concept.concept_id,
-                                        obs_group_id: test.obs_id)
+        result = Lab::LabResult.unscoped.find_by(person_id: encounter.patient_id,
+                                                 concept_id: test_result_concept.concept_id,
+                                                 obs_group_id: test.obs_id,
+                                                 voided: 0)
         return unless result
 
         OrderExtension.find_by(order_id: result.order_id)&.void("Updated/overwritten by #{User.current.username}")
@@ -167,6 +174,7 @@ module Lab
           order_id: results_obs.order_id,
           concept_id: concept_id,
           obs_group_id: results_obs.obs_id,
+          location_id: results_obs.location_id,
           obs_datetime: date&.to_datetime || DateTime.now,
           **make_measure_value(params)
         )

data/app/services/lab/tests_service.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'order_location_resolver'
+
 module Lab
   ##
   # Manage tests that have been ordered through the ordering service.
@@ -29,6 +31,7 @@ module Lab
         raise InvalidParameterError, 'tests are required' if tests_params.nil? || tests_params.empty?
 
         Lab::LabTest.transaction do
+          location_id = Lab::OrderLocationResolver.location_id_for_order(order)
           tests_params.map do |params|
             concept_id = params[:concept_id]
             concept_id = Concept.find_concept_by_uuid(params[:concept]).id if concept_id.nil?
@@ -40,6 +43,7 @@ module Lab
               order_id: order.order_id,
               person_id: order.patient_id,
               obs_datetime: date&.to_time || Time.now,
+              location_id:,
               value_coded: concept_id
             )
 
@@ -123,6 +127,7 @@ module Lab
         )
 
         # Create status observation with 'Drawn' as initial status
+        location_id = Lab::OrderLocationResolver.location_id_for_test(test)
         Observation.create!(
           person_id: test.person_id,
           encounter_id: test.encounter_id,
@@ -137,6 +142,7 @@ module Lab
             'phone_number' => nil
           }.to_json,
           creator: User.current&.user_id || 1,
+          location_id:,
           date_created: Time.now,
           uuid: SecureRandom.uuid
         )

data/lib/lab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lab
-  VERSION = '2.4.1'
+  VERSION = '2.4.2-beta'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: his_emr_api_lab
 version: !ruby/object:Gem::Version
-  version: 2.4.1
+  version: 2.4.2.pre.beta
 platform: ruby
 authors:
 - Elizabeth Glaser Pediatric Foundation Malawi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-26 00:00:00.000000000 Z
+date: 2026-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: couchrest
@@ -286,6 +286,7 @@ files:
 - app/services/lab/lims/worker.rb
 - app/services/lab/metadata.rb
 - app/services/lab/notification_service.rb
+- app/services/lab/order_location_resolver.rb
 - app/services/lab/orders_search_service.rb
 - app/services/lab/orders_service.rb
 - app/services/lab/results_service.rb
@@ -341,9 +342,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.4.1
 signing_key: