his_emr_api_lab 2.1.9.pre.beta → 2.2.1

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

@@ -74,18 +74,85 @@ module Lab
           { tracking_number: order_dto[:tracking_number] }
         end
 
-        def consume_orders(*_args, patient_id: nil, **_kwargs)
-          orders_pending_updates(patient_id).each do |order|
+        def consume_orders(*_args, patient_id: nil, start_date: nil, **_kwargs)
+          orders_pending_updates(patient_id, start_date: start_date).each do |order|
             order_dto = Lab::Lims::OrderSerializer.serialize_order(order)
-            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))
+
+            # 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")
             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 # 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
+              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
               end
             end
 
@@ -227,7 +294,7 @@ module Lab
           {
             order: {
               tracking_number: order_dto.fetch(:tracking_number),
-              district: order_dto.fetch(:districy),
+              district: current_district,
               health_facility_name: order_dto.fetch(:sending_facility),
               sending_facility: order_dto.fetch(:sending_facility),
               arv_number: order_dto.fetch(:patient).fetch(:arv_number),
@@ -281,17 +348,24 @@ module Lab
             status: 'specimen_collected',
             time_updated: date_updated,
             sample_type: order_dto.fetch(:sample_type_map),
-            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)
-              }
-            ]
+            updated_by: status.fetch(:updated_by)
           }
         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)
@@ -437,25 +511,23 @@ 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, test_name, results)
+              params = make_update_test_params(order_dto['tracking_number'], test_name, results)
 
-              RestClient.put(expand_uri("tests/#{order_dto['tracking_number']}", api_version: 'v2'), params, headers)
+              RestClient.post(expand_uri("tests/#{order_dto['tracking_number']}", api_version: 'v2'), params, headers)
             end
           end
         end
 
-        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
+        def make_update_test_params(_tracking_number, test, results, test_status = 'Drawn')
           {
             test_status:,
             time_updated: results['result_date'],
             test_type: {
-              name: concept&.test_catalogue_name,
-              nlims_code: concept&.nlims_code
+              name: ::Concept.find(test.concept_id).test_catalogue_name,
+              nlims_code: ::Concept.find(test.concept_id).nlims_code
             },
-            test_results: results['results'].map do |measure_name, value|
-              measure_value = value['result_value']
+            test_results: results['results'].map do |measure, _value|
+              measure_name, measure_value = measure
               {
                 measure: {
                   name: measure_name,
@@ -467,18 +539,6 @@ 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
@@ -517,46 +577,64 @@ module Lab
           }
         end
 
-        def orders_pending_updates(patient_id = nil)
+        def orders_pending_updates(patient_id = nil, start_date: nil)
           Rails.logger.info('Looking for orders that need to be updated...')
           orders = {}
 
-          orders_without_specimen(patient_id).each { |order| orders[order.order_id] = order }
-          orders_without_results(patient_id).each { |order| orders[order.order_id] = order }
-          orders_without_reason(patient_id).each { |order| orders[order.order_id] = order }
+          orders_without_specimen(patient_id, start_date: start_date).each { |order| orders[order.order_id] = order }
+          orders_without_results(patient_id, start_date: start_date).each { |order| orders[order.order_id] = order }
+          orders_without_reason(patient_id, start_date: start_date).each { |order| orders[order.order_id] = order }
 
           orders.values
         end
 
-        def orders_without_specimen(patient_id = nil)
+        def orders_without_specimen(patient_id = nil, start_date: nil)
           Rails.logger.debug('Looking for orders without a specimen')
           unknown_specimen = ConceptName.where(name: Lab::Metadata::UNKNOWN_SPECIMEN)
                                         .select(:concept_id)
           orders = Lab::LabOrder.where(concept_id: unknown_specimen)
                                 .where.not(accession_number: Lab::LimsOrderMapping.select(:lims_id))
           orders = orders.where(patient_id:) if patient_id
+          orders = orders.where('orders.date_created >= ?', start_date) if start_date
 
           orders
         end
 
-        def orders_without_results(patient_id = nil)
+        def orders_without_results(patient_id = nil, start_date: nil)
           Rails.logger.debug('Looking for orders without a result')
           # Lab::OrdersSearchService.find_orders_without_results(patient_id: patient_id)
           #                         .where.not(accession_number: Lab::LimsOrderMapping.select(:lims_id).where("pulled_at IS NULL"))
-          Lab::OrdersSearchService.find_orders_without_results(patient_id:)
-                                  .where(order_id: Lab::LimsOrderMapping.select(:order_id))
+          orders = Lab::OrdersSearchService.find_orders_without_results(patient_id:)
+                                           .where(order_id: Lab::LimsOrderMapping.select(:order_id))
+          orders = orders.where('orders.date_created >= ?', start_date) if start_date
+          orders
         end
 
-        def orders_without_reason(patient_id = nil)
+        def orders_without_reason(patient_id = nil, start_date: nil)
           Rails.logger.debug('Looking for orders without a reason for test')
           orders = Lab::LabOrder.joins(:reason_for_test)
                                 .merge(Observation.where(value_coded: nil, value_text: nil))
                                 .limit(1000)
                                 .where.not(accession_number: Lab::LimsOrderMapping.select(:lims_id))
           orders = orders.where(patient_id:) if patient_id
+          orders = orders.where('orders.date_created >= ?', start_date) if start_date
 
           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
@@ -685,7 +763,7 @@ module Lab
   def make_create_params(order_dto)
     {
       tracking_number: order_dto.fetch(:tracking_number),
-      district: order_dto.fetch(:districy),
+      district: current_district,
       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),
@@ -723,6 +801,20 @@ 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)

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

@@ -14,17 +14,15 @@ module Lab
 
         def serialize_order(order)
           serialized_order = Lims::Utils.structify(Lab::LabOrderSerializer.serialize_order(order))
-          location = get_location(serialized_order.location_id, order)
-
           Lims::OrderDto.new(
             _id: Lab::LimsOrderMapping.find_by(order: order)&.lims_id || serialized_order.accession_number,
             tracking_number: serialized_order.accession_number,
-            sending_facility: location.name,
+            sending_facility: current_facility_name,
             receiving_facility: serialized_order.target_lab,
             tests: serialized_order.tests.map { |test| format_test_name(test.name) },
             tests_map: serialized_order.tests,
             patient: format_patient(serialized_order.patient_id),
-            order_location: location.name,
+            order_location: format_order_location(serialized_order.encounter_id),
             sample_type: format_sample_type(serialized_order.specimen.name),
             sample_type_map: {
               name: format_sample_type(serialized_order.specimen.name),
@@ -34,7 +32,7 @@ module Lab
             sample_statuses: format_sample_status_trail(order),
             test_statuses: format_test_status_trail(order),
             who_order_test: format_orderer(order),
-            districy: get_district(location), # yes districy [sic]...
+            districy: current_district, # yes districy [sic]...
             priority: format_sample_priority(serialized_order.reason_for_test.name),
             date_created: serialized_order.order_date,
             test_results: format_test_results(serialized_order),
@@ -45,26 +43,13 @@ 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
-
-          raise 'Current health center not set' unless location
+        def format_order_location(encounter_id)
+          location_id = Encounter.select(:location_id).where(encounter_id:)
+          location = Location.select(:name)
+                             .where(location_id:)
+                             .first
 
-          location
+          location&.name
         end
 
         # Format patient into a structure that LIMS expects
@@ -138,13 +123,11 @@ module Lab
         def format_sample_status_trail(order)
           return [] if order.concept_id == ConceptName.find_by_name!('Unknown').concept_id
 
-          user = User.unscoped.find(order.creator)
-          user = User.unscoped.find(order.discontinued_by) if Order.columns_hash.key?('discontinued_by') && user.blank?
+          user = User.find(order.creator)
+          user = User.find(order.discontinued_by) if Order.columns_hash.key?('discontinued_by') && user.blank?
 
           drawn_by = PersonName.find_by_person_id(user.user_id)
-          drawn_date = order.discontinued_date || order.start_date if %w[discontinued_date start_date].all? do |column|
-            order.respond_to?(column)
-          end
+          drawn_date = order.discontinued_date || order.start_date if ['discontinued_date', 'start_date'].all? { |column| order.respond_to?(column) }
           drawn_date ||= order.date_created
 
           [
@@ -196,15 +179,13 @@ module Lab
           order.tests&.each_with_object({}) do |test, results|
             next if test.result.nil? || test.result.empty?
 
-            # Use unscoped to find observations across locations
-            result_obs = Observation.unscoped.find_by(obs_id: test.result.first.id)
+            result_obs = Observation.find_by(obs_id: test.result.first.id)
             unless result_obs
               Rails.logger.warn("Observation with obs_id=#{test.result.first.id} not found for test #{test.name} in order #{order.accession_number}")
               next
             end
 
-            # Use unscoped to find user regardless of location
-            test_creator = User.unscoped.find(result_obs.creator)
+            test_creator = User.find(result_obs.creator)
             test_creator_name = PersonName.find_by_person_id(test_creator.person_id)
 
             results[format_test_name(test.name)] = {
@@ -227,7 +208,7 @@ module Lab
         end
 
         def format_test_name(test_name)
-          test_name
+          return test_name
         end
 
         def format_sample_priority(priority)
@@ -236,11 +217,16 @@ module Lab
           priority&.titleize
         end
 
-        def get_district(location)
-          return nil unless location
+        def current_health_center
+          health_center = Location.current_health_center
+          raise 'Current health center not set' unless health_center
+
+          health_center
+        end
 
-          district = location.city_village \
-                       || location.parent&.name \
+        def current_district
+          district = current_health_center.city_village \
+                       || current_health_center.parent&.name \
                        || GlobalProperty.find_by_property('current_health_center_district')&.property_value
 
           return district if district
@@ -252,8 +238,12 @@ module Lab
           Config.application['district']
         end
 
+        def current_facility_name
+          current_health_center.name
+        end
+
         def find_user(user_id)
-          user = User.unscoped.find(user_id)
+          user = User.find(user_id)
           person_name = PersonName.find_by(person_id: user.person_id)
           phone_number = PersonAttribute.find_by(type: PersonAttributeType.where(name: 'Cell phone number'),
                                                  person_id: user.person_id)

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

@@ -5,14 +5,15 @@ module Lab
     ##
     # Pulls orders from a Lims API object and saves them to the local database.
     class PullWorker
-      attr_reader :lims_api
+      attr_reader :lims_api, :start_date
 
       include Utils # for logger
 
       LIMS_LOG_PATH = Rails.root.join('log', 'lims')
 
-      def initialize(lims_api)
+      def initialize(lims_api, start_date: nil)
         @lims_api = lims_api
+        @start_date = start_date
       end
 
       ##
@@ -20,7 +21,7 @@ module Lab
       def pull_orders(batch_size: 10_000, **)
         logger.info("Retrieving LIMS orders starting from #{last_seq}")
 
-        lims_api.consume_orders(from: last_seq, limit: batch_size, **) do |order_dto, context|
+        lims_api.consume_orders(from: last_seq, limit: batch_size, start_date: start_date, **) do |order_dto, context|
           logger.debug("Retrieved order ##{order_dto[:tracking_number]}: #{order_dto}")
 
           patient = find_patient_by_nhid(order_dto[:patient][:id], order_dto[:tracking_number])
@@ -191,6 +192,11 @@ 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))
+
+        # Extract and save status trails from NLIMS
+        save_status_trails_from_nlims(order, order_dto)
+
+        # Update results if present
         update_results(order, order_dto['test_results']) unless order_dto['test_results'].empty?
 
         order
@@ -200,6 +206,11 @@ module Lab
         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'))
+
+        # Extract and save status trails from NLIMS
+        save_status_trails_from_nlims(order, order_dto)
+
+        # Update results if present
         update_results(order, order_dto['test_results']) unless order_dto['test_results'].empty?
 
         order
@@ -290,6 +301,165 @@ module Lab
         "#{id}:#{first_name} #{last_name}:#{phone_number}"
       end
 
+      def save_status_trails_from_nlims(order, order_dto)
+        logger.debug("Saving status trails from NLIMS for order ##{order['order_id'] || order[:order_id]}")
+        logger.debug("Order DTO keys: #{order_dto.keys.inspect}")
+        logger.debug("Order DTO sample_statuses type: #{order_dto[:sample_statuses].class}")
+        logger.debug("Order DTO sample_statuses content: #{order_dto[:sample_statuses].inspect}")
+
+        # Extract order status trail from sample_statuses (NLIMS uses sample_statuses for order status)
+        # Note: sample_statuses is an array of single-key hashes
+        if order_dto[:sample_statuses].is_a?(Array)
+          logger.debug("Found sample_statuses: #{order_dto[:sample_statuses].size} entries")
+          save_order_status_trails(order, order_dto[:sample_statuses])
+        else
+          logger.warn("No sample_statuses found or not an Array: #{order_dto[:sample_statuses].class}")
+        end
+
+        # Extract test status trails from test_statuses
+        if order_dto['test_statuses'].is_a?(Hash)
+          logger.debug("Found test_statuses: #{order_dto['test_statuses'].keys.size} entries")
+          save_test_status_trails(order, order_dto['test_statuses'])
+        else
+          logger.debug("No test_statuses found or not a Hash: #{order_dto['test_statuses'].class}")
+        end
+      end
+
+      def save_order_status_trails(order, sample_statuses)
+        logger.debug("Saving order status trails for order ##{order['order_id'] || order[:order_id]}")
+        logger.debug("Sample statuses: #{sample_statuses.inspect}")
+
+        # Find concept
+        order_status_concept = ConceptName.find_by(name: 'Lab Order Status')&.concept
+        unless order_status_concept
+          logger.error('Lab Order Status concept not found')
+          return
+        end
+
+        order_id = order['order_id'] || order[:order_id] || order['id'] || order[:id]
+        lab_order = Lab::LabOrder.find_by(order_id: order_id)
+        unless lab_order
+          logger.error("Order not found: #{order_id}")
+          return
+        end
+
+        # sample_statuses is an array of single-key hashes like:
+        # [{ "20260225120000" => { "status" => "Drawn", ... } }, { "20260225130000" => { ... } }]
+        sample_statuses.each do |trail_entry|
+          # Each trail_entry is a hash with one timestamp key
+          trail_entry.each_pair do |timestamp_key, status_data|
+            next unless status_data.is_a?(Hash) && status_data['status']
+
+            # Parse timestamp (format: YYYYMMDDHHmmss) - already in local timezone from NLIMS conversion
+            # Use Time.zone.strptime to prevent Rails from converting timezone during save
+            begin
+              timestamp = Time.zone.strptime(timestamp_key, '%Y%m%d%H%M%S')
+            rescue StandardError => e
+              logger.warn("Failed to parse timestamp '#{timestamp_key}': #{e.message}")
+              next
+            end
+
+            # Skip if this status has already been recorded for this order (regardless of timestamp)
+            if Observation.unscoped.exists?(
+              person_id: lab_order.patient_id,
+              order_id: order_id,
+              concept_id: order_status_concept.concept_id,
+              value_text: status_data['status'],
+              voided: 0
+            )
+              logger.debug("Order status already recorded: #{status_data['status']} for order ##{order_id}")
+              next
+            end
+
+            updated_by = status_data['updated_by'] || {}
+
+            begin
+              Observation.create!(
+                person_id: lab_order.patient_id,
+                encounter_id: lab_order.encounter_id,
+                order_id: order_id,
+                concept_id: order_status_concept.concept_id,
+                value_text: status_data['status'], # Store status as text
+                obs_datetime: timestamp,
+                comments: updated_by.to_json,
+                creator: User.current&.user_id || 1,
+                date_created: Time.now,
+                uuid: SecureRandom.uuid
+              )
+              logger.info("Created order status trail: #{status_data['status']} at #{timestamp}")
+            rescue StandardError => e
+              logger.error("Failed to save order status trail: #{e.message}")
+              logger.error("  Order ID: #{order_id}")
+              logger.error("  Status: #{status_data['status']}")
+              logger.error("  Timestamp: #{timestamp}")
+            end
+          end
+        end
+      end
+
+      def save_test_status_trails(order, test_statuses)
+        # Find test status concept
+        test_status_concept = ConceptName.find_by(name: 'Lab Test Status')&.concept
+        unless test_status_concept
+          logger.error('Lab Test Status concept not found')
+          return
+        end
+
+        test_statuses.each do |test_name, statuses|
+          next unless statuses.is_a?(Hash)
+
+          # Find the test by name
+          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)
+          next unless test
+
+          # Process each status in the trail
+          statuses.each do |timestamp_key, status_data|
+            next unless status_data.is_a?(Hash) && status_data['status']
+
+            # Parse timestamp (format: YYYYMMDDHHmmss) - already in local timezone from NLIMS conversion
+            # Use Time.zone.strptime to prevent Rails from converting timezone during save
+            begin
+              timestamp = Time.zone.strptime(timestamp_key, '%Y%m%d%H%M%S')
+            rescue StandardError => e
+              logger.warn("Failed to parse timestamp '#{timestamp_key}': #{e.message}")
+              next
+            end
+
+            # Skip if this status has already been recorded for this test (regardless of timestamp)
+            next if Observation.unscoped.exists?(
+              person_id: test.person_id,
+              obs_group_id: test.obs_id,
+              concept_id: test_status_concept.concept_id,
+              value_text: status_data['status'],
+              voided: 0
+            )
+
+            updated_by = status_data['updated_by'] || {}
+
+            begin
+              Observation.create!(
+                person_id: test.person_id,
+                encounter_id: test.encounter_id,
+                obs_group_id: test.obs_id,
+                concept_id: test_status_concept.concept_id,
+                value_text: status_data['status'], # Store status as text
+                obs_datetime: timestamp,
+                comments: updated_by.to_json,
+                creator: User.current&.user_id || 1,
+                date_created: Time.now,
+                uuid: SecureRandom.uuid
+              )
+              logger.info("Created test status trail: #{status_data['status']} at #{timestamp} for #{test_name}")
+            rescue StandardError => e
+              logger.error("Failed to save test status trail for #{test_name}: #{e.message}")
+            end
+          end
+        end
+      end
+
       def save_failed_import(order_dto, reason, diff = nil)
         logger.info("Failed to import LIMS order ##{order_dto[:tracking_number]} due to '#{reason}'")
         LimsFailedImport.create!(lims_id: order_dto[:_id],