his_emr_api_lab 2.1.8.7 → 2.1.9.pre.alpha

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

@@ -5,15 +5,14 @@ module Lab
     ##
     # Pulls orders from a Lims API object and saves them to the local database.
     class PullWorker
-      attr_reader :lims_api, :start_date
+      attr_reader :lims_api
 
       include Utils # for logger
 
       LIMS_LOG_PATH = Rails.root.join('log', 'lims')
 
-      def initialize(lims_api, start_date: nil)
+      def initialize(lims_api)
         @lims_api = lims_api
-        @start_date = start_date
       end
 
       ##
@@ -21,7 +20,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, start_date: start_date, **) do |order_dto, context|
+        lims_api.consume_orders(from: last_seq, limit: batch_size, **) 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])
@@ -192,6 +191,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
@@ -201,6 +205,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
@@ -291,6 +300,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],

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

@@ -5,16 +5,15 @@ module Lab
     ##
     # Pushes all local orders to a LIMS Api object.
     class PushWorker
-      attr_reader :lims_api, :start_date
+      attr_reader :lims_api
 
       include Utils # for logger
 
       SECONDS_TO_WAIT_FOR_ORDERS = 30
       START_DATE = Time.parse('2024-09-03').freeze
 
-      def initialize(lims_api, start_date: nil)
+      def initialize(lims_api)
         @lims_api = lims_api
-        @start_date = start_date
       end
 
       def push_orders(batch_size: 1000, wait: false)
@@ -82,8 +81,8 @@ module Lab
 
       def void_order_in_lims(order_id)
         order = Lab::LabOrder.joins(order_type: { name: 'Lab' })
-                             .unscoped
-                             .find(order_id)
+        .unscoped
+        .find(order_id)
         order_dto = Lab::Lims::OrderSerializer.serialize_order(order)
         Rails.logger.info("Deleting order ##{order_dto[:accession_number]} from LIMS")
         lims_api.delete_order('', order_dto)
@@ -101,17 +100,10 @@ module Lab
 
       def new_orders
         Rails.logger.debug('Looking for new orders that need to be created in LIMS...')
-        query = Lab::LabOrder.joins('LEFT JOIN lab_lims_order_mappings ON lab_lims_order_mappings.order_id = orders.order_id')
-                             .where('lab_lims_order_mappings.order_id IS NULL')
-                             .where("accession_number IS NOT NULL AND accession_number !=''")
-
-        query = if start_date
-                  query.where('orders.date_created >= ?', start_date)
-                else
-                  query.where('orders.date_created >= ? AND orders.date_created <= ?', START_DATE, Date.today + 1.day)
-                end
-
-        query.order(date_created: :desc)
+        Lab::LabOrder.where.not(order_id: Lab::LimsOrderMapping.all.select(:order_id))
+                     .where("accession_number IS NOT NULL AND accession_number !=''")
+                     .where(date_created: START_DATE..(Date.today + 1.day))
+                     .order(date_created: :desc)
       end
 
       def updated_orders
@@ -119,26 +111,23 @@ module Lab
         last_updated = Lab::LimsOrderMapping.select('MAX(updated_at) AS last_updated')
                                             .first
                                             .last_updated
-        last_updated = start_date if start_date && last_updated < start_date
 
         Lab::LabOrder.left_joins(:results)
                      .joins(:mapping)
-                     .where('(orders.discontinued_date > :last_updated
-                             OR (obs.date_created > orders.date_created AND orders.date_created >= :last_updated)) AND lab_lims_order_mappings.result_push_status = 0',
+                     .where('orders.discontinued_date > :last_updated
+                             OR obs.date_created > orders.date_created AND lab_lims_order_mappings.result_push_status = 0',
                             last_updated:)
                      .group('orders.order_id')
                      .order(discontinued_date: :desc, date_created: :desc)
       end
 
       def voided_orders
-        # add date filter to avoid pushing voided orders that were created a long time ago
         Rails.logger.debug('Looking for voided orders that are being tracked by LIMS...')
-        orders = Lab::LabOrder.unscoped
-                              .joins('INNER JOIN lab_lims_order_mappings ON lab_lims_order_mappings.order_id = orders.order_id')
-                              .where(order_type: OrderType.where(name: Lab::Metadata::ORDER_TYPE_NAME),
-                                     voided: 1)
-        orders = orders.where('orders.date_created >= ?', start_date) if start_date
-        orders.order(date_voided: :desc)
+        Lab::LabOrder.unscoped
+                     .where(order_type: OrderType.where(name: Lab::Metadata::ORDER_TYPE_NAME),
+                            order_id: Lab::LimsOrderMapping.all.select(:order_id),
+                            voided: 1)
+                     .order(date_voided: :desc)
       end
 
       ##

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

@@ -9,43 +9,43 @@ module Lab
     ##
     # Pull/Push orders from/to the LIMS queue (Oops meant CouchDB).
     module Worker
-      def self.start(start_date: nil)
+      def self.start
         User.current = Utils.lab_user
 
-        fork { start_push_worker(start_date: start_date) }
-        fork { start_pull_worker(start_date: start_date) }
-        fork { start_acknowledgement_worker(start_date: start_date) }
-        fork { start_realtime_pull_worker(start_date: start_date) } if realtime_updates_enabled?
+        fork(&method(:start_push_worker))
+        fork(&method(:start_pull_worker))
+        fork(&method(:start_acknowledgement_worker))
+        fork(&method(:start_realtime_pull_worker)) if realtime_updates_enabled?
 
         Process.waitall
       end
 
-      def self.start_push_worker(start_date: nil)
+      def self.start_push_worker
         start_worker('push_worker') do
-          worker = PushWorker.new(lims_api, start_date: start_date)
+          worker = PushWorker.new(lims_api)
 
           worker.push_orders # (wait: true)
         end
       end
 
-      def self.start_acknowledgement_worker(start_date: nil)
+      def self.start_acknowledgement_worker
         start_worker('acknowledgement_worker') do
-          worker = AcknowledgementWorker.new(lims_api, start_date: start_date)
+          worker = AcknowledgementWorker.new(lims_api)
           worker.push_acknowledgement
         end
       end
 
-      def self.start_pull_worker(start_date: nil)
+      def self.start_pull_worker
         start_worker('pull_worker') do
-          worker = PullWorker.new(lims_api, start_date: start_date)
+          worker = PullWorker.new(lims_api)
 
           worker.pull_orders
         end
       end
 
-      def self.start_realtime_pull_worker(start_date: nil)
+      def self.start_realtime_pull_worker
         start_worker('realtime_pull_worker') do
-          worker = PullWorker.new(Lims::Api::WsApi.new(Lab::Lims::Config.updates_socket), start_date: start_date)
+          worker = PullWorker.new(Lims::Api::WsApi.new(Lab::Lims::Config.updates_socket))
 
           worker.pull_orders
         end

data/app/services/lab/metadata.rb

@@ -12,6 +12,7 @@ module Lab
     TEST_RESULT_INDICATOR_CONCEPT_NAME = 'Lab test result indicator'
     TEST_TYPE_CONCEPT_NAME = 'Test type'
     LAB_ORDER_STATUS_CONCEPT_NAME = 'lab order status'
+    LAB_TEST_STATUS_CONCEPT_NAME = 'lab test status'
     UNKNOWN_SPECIMEN = 'Unknown'
     VISIT_TYPE_UUID = '8a4a4488-c2cc-11de-8d13-0010c6dffd0f'
     TEST_METHOD_CONCEPT_NAME = 'Recommended test method'