his_emr_api_lab 2.4.4 → 2.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f50deefb7cbd1c86b4b08b3c22d173f48a1a8da57399051247a6cd71fdc631ae
-  data.tar.gz: 621cb083624e5fde98f425946a0efbfcf8104151140d72c9047a478fab4ca305
+  metadata.gz: 2ac3fb7e82f896ac9c5f0545aa1c7e97290e7aaf11cc149fd6e8f385938397dc
+  data.tar.gz: 707411853618c5b391c99ecdc043bdbc71ef5df5a1b801567869d279b068c6d7
 SHA512:
-  metadata.gz: dbf52fd1e2efb47895308e668f120de8ae39abbd4ca51ed3a9a32f494669db317dfb3be1b5fb86bd5a770311fb175a06ed127c29a0a8296c2d6275db3f57b4b9
-  data.tar.gz: 9379bc707799b2db5cca3d4033c3b845a802a7b811584ed057235e407a405ebc09d99a6614e7c21a2835494e0df64f06c6d02ca8e71ae6e6a02ad5ce074b8dfe
+  metadata.gz: e0ae79db2d3cb66121a3daf92c1fb0e141a09309dc148f604da49cb167203fe22c77e50c843a9a10e6531fe505cb8241c5212668a643bff38ef5f851d8232a72
+  data.tar.gz: 32ec983d0e45aa6af8b280ae1850544ad42bb250465cdfa45a597818e589c3ff9238d7ebea7ba7cdc7c613ae4f2368fc05c2c854809fa2f1d2d8b76ed82c1bcf

data/app/services/lab/acknowledgement_service.rb

@@ -14,11 +14,13 @@ module Lab
                                         date_received: params[:date_received])
       end
 
-      def acknowledgements_pending_sync(batch_size, start_date: nil, last_order_id: 0)
+      def acknowledgements_pending_sync(batch_size, start_date: nil, last_order_id: 0, accession_numbers: [], patient_id: nil)
         query = Lab::LabAcknowledgement.joins(:order).where(pushed: false)
                                        .where('lims_acknowledgement_statuses.order_id > ?', last_order_id)
         query = query.where('orders.date_created >= ?', start_date) if start_date
-        query.order('lims_acknowledgement_statuses.order_id ASC').limit(batch_size)
+        query = query.where(orders: {accession_number: accession_numbers}) if accession_numbers.any?
+        query = query.where(orders: {patient_id: patient_id}) if patient_id
+        query.order('lims_acknowledgement_statuses.order_id DESC').limit(batch_size)
       end
 
       def push_acknowledgement(acknowledgement, lims_api)

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

@@ -4,15 +4,17 @@ module Lab
   module Lims
     # This class is responsible for handling the acknowledgement of lab orders
     class AcknowledgementWorker
-      attr_reader :lims_api, :start_date
+      attr_reader :lims_api, :start_date, :accession_numbers, :patient_id
 
       include Utils # for logger
 
       SECONDS_TO_WAIT_FOR_ORDERS = 30
 
-      def initialize(lims_api, start_date: nil)
+      def initialize(lims_api, start_date: nil, accession_numbers: [], patient_id: nil)
         @lims_api = lims_api
         @start_date = start_date
+        @accession_numbers = accession_numbers
+        @patient_id = patient_id
       end
 
       def push_acknowledgement(batch_size: 1000, wait: false)
@@ -21,6 +23,8 @@ module Lab
           logger.info('Looking for new acknowledgements to push to LIMS...')
           acknowledgements = Lab::AcknowledgementService.acknowledgements_pending_sync(batch_size,
                                                                                        start_date: start_date,
+                                                                                       accession_numbers: accession_numbers,
+                                                                                       patient_id: patient_id,
                                                                                        last_order_id: last_order_id).all
 
           logger.debug("Found #{acknowledgements.size} acknowledgements...")

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

@@ -75,8 +75,8 @@ module Lab
           { tracking_number: order_dto[:tracking_number] }
         end
 
-        def consume_orders(*_args, patient_id: nil, start_date: nil, **_kwargs)
-          orders_pending_updates(patient_id, start_date: start_date).each do |order|
+        def consume_orders(*_args, patient_id: nil, start_date: nil, accession_numbers: [], **_kwargs)
+          orders_pending_updates(patient_id, start_date: start_date, accession_numbers: accession_numbers).each do |order|
             order_dto = Lab::Lims::OrderSerializer.serialize_order(order)
 
             # Always fetch the full order from NLIMS to get status trails
@@ -84,11 +84,6 @@ module Lab
               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
@@ -606,18 +601,20 @@ module Lab
           }
         end
 
-        def orders_pending_updates(patient_id = nil, start_date: nil)
-          Rails.logger.info('Looking for orders that need to be updated...')
+        def orders_pending_updates(patient_id = nil, start_date: nil, accession_numbers: [])
+          Rails.logger.info("Looking for orders that need to be updated... [patient_id=#{patient_id}] [start_date=#{start_date}]")
           orders = {}
-
-          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 }
+          Rails.logger.info("Fetching orders without specimen...")
+          orders_without_specimen(patient_id, start_date: start_date, accession_numbers: accession_numbers).each { |order| orders[order.order_id] = order }
+          Rails.logger.info("Fetching orders without results...")
+          orders_without_results(patient_id, start_date: start_date, accession_numbers: accession_numbers).each { |order| orders[order.order_id] = order }
+          Rails.logger.info("Fetching orders without reason...")
+          orders_without_reason(patient_id, start_date: start_date, accession_numbers: accession_numbers).each { |order| orders[order.order_id] = order }
 
           orders.values
         end
 
-        def orders_without_specimen(patient_id = nil, start_date: nil)
+        def orders_without_specimen(patient_id = nil, start_date: nil, accession_numbers: [])
           Rails.logger.debug('Looking for orders without a specimen')
           unknown_specimen = ConceptName.where(name: Lab::Metadata::UNKNOWN_SPECIMEN)
                                         .select(:concept_id)
@@ -625,21 +622,23 @@ module Lab
                                 .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 = orders.where(accession_number: accession_numbers) if accession_numbers.any?
 
           orders
         end
 
-        def orders_without_results(patient_id = nil, start_date: nil)
+        def orders_without_results(patient_id = nil, start_date: nil, accession_numbers: [])
           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"))
           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 = orders.where(accession_number: accession_numbers) if accession_numbers.any?
           orders
         end
 
-        def orders_without_reason(patient_id = nil, start_date: nil)
+        def orders_without_reason(patient_id = nil, start_date: nil, accession_numbers: [])
           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))
@@ -647,6 +646,7 @@ module Lab
                                 .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 = orders.where(accession_number: accession_numbers) if accession_numbers.any?
 
           orders
         end

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

@@ -7,15 +7,17 @@ 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, :start_date, :accession_numbers
 
       include Utils # for logger
 
       LIMS_LOG_PATH = Rails.root.join('log', 'lims')
 
-      def initialize(lims_api, start_date: nil)
+      def initialize(lims_api, start_date: nil, accession_numbers: [], patient_id: nil)
         @lims_api = lims_api
         @start_date = start_date
+        @accession_numbers = accession_numbers
+        @patient_id = patient_id
       end
 
       ##
@@ -23,7 +25,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, start_date: start_date, accession_numbers: accession_numbers, **) 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])
@@ -395,7 +397,7 @@ module Lab
                 value_text: status_data['status'], # Store status as text
                 obs_datetime: timestamp,
                 comments: updated_by.to_json,
-                creator: User.current&.user_id || 1,
+                creator: User.current&.user_id,
                 location_id:,
                 date_created: Time.now,
                 uuid: SecureRandom.uuid
@@ -463,7 +465,7 @@ module Lab
                 value_text: status_data['status'], # Store status as text
                 obs_datetime: timestamp,
                 comments: updated_by.to_json,
-                creator: User.current&.user_id || 1,
+                creator: User.current&.user_id,
                 location_id:,
                 date_created: Time.now,
                 uuid: SecureRandom.uuid

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

@@ -5,16 +5,18 @@ module Lab
     ##
     # Pushes all local orders to a LIMS Api object.
     class PushWorker
-      attr_reader :lims_api, :start_date
+      attr_reader :lims_api, :start_date, :accession_numbers, :patient_id
 
       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, start_date: nil, accession_numbers: [], patient_id: nil)
         @lims_api = lims_api
         @start_date = start_date
+        @accession_numbers = accession_numbers
+        @patient_id = patient_id
       end
 
       def push_orders(batch_size: 1000, wait: false)
@@ -109,7 +111,8 @@ module Lab
                 else
                   query.where('orders.date_created >= ? AND orders.date_created <= ?', START_DATE, Date.today + 1.day)
                 end
-
+        query = query.where(accession_number: accession_numbers) if accession_numbers.any?
+        query = query.where(patient_id: patient_id) if patient_id
         query.order(date_created: :desc)
       end
 
@@ -130,11 +133,14 @@ module Lab
 
       def voided_orders
         Rails.logger.debug('Looking for voided orders that are being tracked by LIMS...')
-        Lab::LabOrder.unscoped
+        orders = 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)
+        orders = orders.where(accession_number: accession_numbers) if accession_numbers.any?
+        orders = orders.where(patient_id: patient_id) if patient_id
+        orders = orders.order(date_voided: :desc)
+        orders
       end
 
       ##

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

@@ -9,46 +9,46 @@ module Lab
     ##
     # Pull/Push orders from/to the LIMS queue (Oops meant CouchDB).
     module Worker
-      def self.start(start_date: nil)
+      def self.start(start_date: nil, accession_numbers: [], patient_id: nil)
         User.current = Utils.lab_user
 
         # Eager load classes before forking to avoid autoloading issues in child processes
         Rails.application.eager_load! if defined?(Rails) && Rails.env.development?
 
-        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 { start_push_worker(start_date: start_date, accession_numbers: accession_numbers, patient_id: patient_id) }
+        fork { start_pull_worker(start_date: start_date, accession_numbers: accession_numbers, patient_id: patient_id) }
+        fork { start_acknowledgement_worker(start_date: start_date, accession_numbers: accession_numbers, patient_id: patient_id) }
+        fork { start_realtime_pull_worker(start_date: start_date, accession_numbers: accession_numbers, patient_id: patient_id) } if realtime_updates_enabled?
 
         Process.waitall
       end
 
-      def self.start_push_worker(start_date: nil)
-        start_worker('push_worker') do
-          worker = PushWorker.new(lims_api, start_date: start_date)
+      def self.start_push_worker(start_date: nil, accession_numbers: [], patient_id: nil)
+        start_worker('push_worker', accession_numbers: accession_numbers, patient_id: patient_id) do
+          worker = PushWorker.new(lims_api, start_date: start_date, accession_numbers: accession_numbers, patient_id: patient_id)
 
           worker.push_orders # (wait: true)
         end
       end
 
-      def self.start_acknowledgement_worker(start_date: nil)
-        start_worker('acknowledgement_worker') do
-          worker = AcknowledgementWorker.new(lims_api, start_date: start_date)
+      def self.start_acknowledgement_worker(start_date: nil, accession_numbers: [], patient_id: nil)
+        start_worker('acknowledgement_worker', accession_numbers: accession_numbers, patient_id: patient_id) do
+          worker = AcknowledgementWorker.new(lims_api, start_date: start_date, accession_numbers: accession_numbers, patient_id: patient_id)
           worker.push_acknowledgement
         end
       end
 
-      def self.start_pull_worker(start_date: nil)
-        start_worker('pull_worker') do
-          worker = PullWorker.new(lims_api, start_date: start_date)
+      def self.start_pull_worker(start_date: nil, accession_numbers: [], patient_id: nil)
+        start_worker('pull_worker', accession_numbers: accession_numbers, patient_id: patient_id) do
+          worker = PullWorker.new(lims_api, start_date: start_date, accession_numbers: accession_numbers, patient_id: patient_id)
 
           worker.pull_orders
         end
       end
 
-      def self.start_realtime_pull_worker(start_date: nil)
-        start_worker('realtime_pull_worker') do
-          worker = PullWorker.new(Lims::Api::WsApi.new(Lab::Lims::Config.updates_socket), start_date: start_date)
+      def self.start_realtime_pull_worker(start_date: nil, accession_numbers: [], patient_id: nil)
+        start_worker('realtime_pull_worker', accession_numbers: accession_numbers, patient_id: patient_id) do
+          worker = PullWorker.new(Lims::Api::WsApi.new(Lab::Lims::Config.updates_socket), start_date: start_date, accession_numbers: accession_numbers, patient_id: patient_id)
 
           worker.pull_orders
         end
@@ -57,7 +57,8 @@ module Lab
       LOG_FILES_TO_KEEP = 5
       LOG_FILE_SIZE = 500.megabytes
 
-      def self.start_worker(worker_name)
+      def self.start_worker(worker_name, accession_numbers: [], patient_id: nil)
+        worker_name = create_file_name(worker_name, accession_numbers: accession_numbers, patient_id: patient_id)
         Rails.logger = LoggerMultiplexor.new(file_logger(worker_name), $stdout)
         ActiveRecord::Base.logger = Rails.logger
         Rails.logger.level = :debug
@@ -78,6 +79,15 @@ module Lab
         Logger.new(log_path("#{worker_name}.log"), LOG_FILES_TO_KEEP, LOG_FILE_SIZE)
       end
 
+      def self.create_file_name(worker_name, accession_numbers: [], patient_id: nil)
+        accession_numbers = accession_numbers.nil? ? [] : accession_numbers
+        accession_numbers = accession_numbers.map { |accession| accession.gsub(/[^a-zA-Z0-9]/, '') }.join('_')
+        filename = "#{worker_name}"
+        filename += "_#{accession_numbers}" unless accession_numbers.empty?
+        filename += "_#{patient_id}" if patient_id
+        filename
+      end
+
       def self.log_path(filename)
         Lab::Lims::Utils::LIMS_LOG_PATH.join(filename)
       end

data/app/services/lab/notification_service.rb

@@ -88,13 +88,40 @@ class Lab::NotificationService
     Observation.find_by(order_id: order_id)&.location_id
   end
 
-  def notify(notification_alert, recipients)    
-    recipients.each do |recipient|
-      next if recipient.notification_alert_recipients.exists?(alert_id: notification_alert.id)
+  # Was one exists? + one create per recipient (2 round trips x N users,
+  # sequentially) - the slow part users() and order_location() were feeding
+  # into. notification_alert_recipient's primary key is (alert_id, user_id),
+  # so a single batched insert_all does the "notify each user at most once
+  # per alert" dedup at the DB level instead of a round trip per user.
+  #
+  # Plain insert_all, no unique_by/on_duplicate kwargs - verified live
+  # against this app's Rails 8.1/mysql2 combination:
+  #   - relation.rb's insert_all hardcodes InsertAll.execute(..., on_duplicate:
+  #     :skip, ...) internally; on_duplicate isn't a caller-facing keyword at
+  #     all (passing it raises "unknown keyword: :on_duplicate"), and skip-on-
+  #     duplicate is already what plain insert_all does by default.
+  #   - unique_by IS a caller-facing keyword, but only for adapters that need
+  #     to be told which constraint backs the ON CONFLICT target (e.g.
+  #     Postgres). Passing it here raises "Mysql2Adapter does not support
+  #     :unique_by" - MySQL's own INSERT IGNORE applies to any unique/primary
+  #     -key violation on the table, so it needs nothing extra to know that
+  #     (alert_id, user_id) is the key to dedup against.
+  #
+  # insert_all skips AR callbacks, so uuid - the one thing the model's
+  # before_create/before_save would have set - is generated here;
+  # alert_read/cleared/date_changed are left to their column defaults.
+  # Chunked so one notification fan-out to a very large recipient list
+  # doesn't become a single giant statement.
+  BATCH_SIZE = 1000
+
+  def notify(notification_alert, recipients)
+    rows = recipients.pluck(:user_id).map do |user_id|
+      { alert_id: notification_alert.id, user_id: user_id, uuid: SecureRandom.uuid }
+    end
+    return if rows.empty?
 
-      recipient.notification_alert_recipients.create(
-        alert_id: notification_alert.id
-      )
+    rows.each_slice(BATCH_SIZE) do |batch|
+      NotificationAlertRecipient.insert_all(batch)
     end
   end
 

data/app/services/lab/orders_search_service.rb

@@ -25,7 +25,14 @@ module Lab
       end
 
       def find_orders_without_results(patient_id: nil)
-        results_query = Lab::LabResult.all
+        # order_id IS NOT NULL matters here, not just there: SQL's NOT IN is
+        # poisoned by a single NULL in the subquery — `x NOT IN (1, NULL)` is
+        # never true for any x, because `x <> NULL` is unknown rather than
+        # true/false, and one unknown collapses the whole AND chain. Some
+        # legacy "Lab test result" observations have a NULL order_id, so
+        # without this filter, one such row for a patient silently zeroes out
+        # every order this returns for them, not just the row with the NULL.
+        results_query = Lab::LabResult.all.where.not(order_id: nil)
         results_query = results_query.where(person_id: patient_id) if patient_id
 
         query = Lab::LabOrder.where.not(order_id: results_query.select(:order_id))

data/app/services/lab/orders_service.rb

@@ -600,7 +600,7 @@ module Lab
           value_text: status, # Store status as text
           obs_datetime: timestamp,
           comments: updated_by.to_json,
-          creator: User.current&.user_id || 1,
+          creator: User.current&.user_id,
           location_id:,
           date_created: Time.now,
           uuid: SecureRandom.uuid
@@ -641,7 +641,7 @@ module Lab
           value_text: status, # Store status as text
           obs_datetime: timestamp,
           comments: updated_by.to_json,
-          creator: User.current&.user_id || 1,
+          creator: User.current&.user_id,
           location_id:,
           date_created: Time.now,
           uuid: SecureRandom.uuid

data/app/services/lab/tests_service.rb

@@ -141,7 +141,7 @@ module Lab
             'id' => User.current&.user_id&.to_s,
             'phone_number' => nil
           }.to_json,
-          creator: User.current&.user_id || 1,
+          creator: User.current&.user_id,
           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.4'.freeze
+  VERSION = '2.4.6'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: his_emr_api_lab
 version: !ruby/object:Gem::Version
-  version: 2.4.4
+  version: 2.4.6
 platform: ruby
 authors:
 - Elizabeth Glaser Pediatric Foundation Malawi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-24 00:00:00.000000000 Z
+date: 2026-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: couchrest