his_emr_api_lab 2.1.8.4 → 2.1.8.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48bde24dfa632a5401c2d51ed64497181abce1eaa5383a9f89ffb97b6d53630d
-  data.tar.gz: c7ad332d6c9f695202965f7402a51eb4d456dfd3f8d243004ab0ce8bd3df7b87
+  metadata.gz: 9d62deddcd36f58905cb31ed7240186170e63bb60024a9b7f1adbeeba2b7fa02
+  data.tar.gz: 5396bb200c07079f19b12004fb2fa11af844b0c24ae8f90a7a076f474c7d1867
 SHA512:
-  metadata.gz: 360c583e51172ae67a2af0a7c0936ffd51bccf304ca01183400c532a97e30f31c898e790f3333011167674983b06946ddf754d1a9d69cb69294f747f5192251e
-  data.tar.gz: 8b8b915e976ade5664acd97cf310cf78d21a8e3000dad43dfad2198438358bffb3f44c61aa90f6f417d2156e78a71f5a54fe181ee9ceed8e09f24f4e42c2eaf7
+  metadata.gz: 0fc83099a46e0b9879c9d489b507e3b04444e1dba215d2c3632290b937092b83682938ef3a4991851acdd725f0dbff30766ff9024378e67520b628bf8d5b170c
+  data.tar.gz: 58b1df7bff8f2ed90083d24a382d20dc963604574f94024a98408f1ec1ef9afa4e407f651bbd82863c2355ffef81cdccb8bea224c2516fb9d3a00420abbc0bce

data/app/jobs/lab/process_lab_result_job.rb

@@ -7,7 +7,7 @@ module Lab
     queue_as :default
     def perform(results_obs_id, serializer, result_enter_by)
       Rails.logger.info("Lab::ProcessLabResultJob: Processing result completion for #{serializer}")
-      results_obs = Lab::LabResult.find(results_obs_id)
+      results_obs = Lab::LabResult.unscoped.find(results_obs_id)
       Lab::ResultsService.process_result_completion(results_obs, serializer, result_enter_by)
     end
   end

data/app/serializers/lab/lab_order_serializer.rb

@@ -66,7 +66,8 @@ module Lab
     def self.concept_name(concept_id)
       return concept_id unless concept_id
 
-      ::ConceptAttribute.find_by(concept_id:, attribute_type: ConceptAttributeType.test_catalogue_name)&.value_reference
+      c_name = ::ConceptAttribute.find_by(concept_id:, attribute_type: ConceptAttributeType.test_catalogue_name)&.value_reference
+      c_name || ConceptName.find_by_concept_id(concept_id)&.name
     end
 
     def self.voided_tests(order)

data/app/services/lab/acknowledgement_service.rb

@@ -14,9 +14,12 @@ module Lab
                                         date_received: params[:date_received])
       end
 
-      def acknowledgements_pending_sync(batch_size)
-        Lab::LabAcknowledgement.where(pushed: false)
-                               .limit(batch_size)
+      def acknowledgements_pending_sync(batch_size, start_date: nil)
+        query = Lab::LabAcknowledgement.joins(:order).where(pushed: false)
+
+        query = query.where('orders.date_created >= ?', start_date) if start_date
+
+        query.limit(batch_size)
       end
 
       def push_acknowledgement(acknowledgement, lims_api)
@@ -30,7 +33,8 @@ module Lab
             Rails.logger.info("Updating acknowledgement ##{acknowledgement_dto[:tracking_number]} in LIMS")
             response = lims_api.acknowledge(acknowledgement_dto)
             Rails.logger.info("Info #{response}")
-            if ['results already delivered for test name given', 'test result acknowledged successfully', 'test result already acknowledged electronically at facility'].include?(response['message'])
+            if ['results already delivered for test name given', 'test result acknowledged successfully',
+                'test result already acknowledged electronically at facility'].include?(response['message'])
               acknowledgement.pushed = true
               acknowledgement.date_pushed = Time.now
               acknowledgement.save!

data/app/services/lab/concepts_service.rb

@@ -34,10 +34,11 @@ module Lab
 
       unless specimen_type
         return ActiveRecord::Base.connection.select_all <<~SQL
-          SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code
+          SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code, c.uuid
             FROM concept_attribute ca
           INNER JOIN concept_attribute ca2 ON ca.concept_id = ca2.concept_id
             AND ca2.attribute_type_id = #{ConceptAttributeType.nlims_code.concept_attribute_type_id}
+          INNER JOIN concept c ON c.concept_id = ca.concept_id
           WHERE ca.attribute_type_id = #{ConceptAttributeType.test_catalogue_name.concept_attribute_type_id}
           AND ca.concept_id IN (#{test_types.select(:concept_id).to_sql})
           GROUP BY ca.concept_id
@@ -56,10 +57,11 @@ module Lab
       )
 
       return ActiveRecord::Base.connection.select_all <<~SQL
-        SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code
+        SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code, c.uuid
           FROM concept_attribute ca
         INNER JOIN concept_attribute ca2 ON ca.concept_id = ca2.concept_id
           AND ca2.attribute_type_id = #{ConceptAttributeType.nlims_code.concept_attribute_type_id}
+        INNER JOIN concept c ON c.concept_id = ca.concept_id
         WHERE ca.attribute_type_id = #{ConceptAttributeType.test_catalogue_name.concept_attribute_type_id}
         AND ca.concept_id IN (#{concept_set.select(:concept_set).to_sql})
         GROUP BY ca.concept_id
@@ -72,10 +74,11 @@ module Lab
 
       unless test_type
         return ActiveRecord::Base.connection.select_all <<~SQL
-          SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code
+          SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code, c.uuid
             FROM concept_attribute ca
           INNER JOIN concept_attribute ca2 ON ca.concept_id = ca2.concept_id
             AND ca2.attribute_type_id = #{ConceptAttributeType.nlims_code.concept_attribute_type_id}
+          INNER JOIN concept c ON c.concept_id = ca.concept_id
           WHERE ca.attribute_type_id = #{ConceptAttributeType.test_catalogue_name.concept_attribute_type_id}
           AND ca.concept_id IN (#{specimen_types.select(:concept_id).to_sql})
           GROUP BY ca.concept_id
@@ -94,10 +97,11 @@ module Lab
       )
 
       return ActiveRecord::Base.connection.select_all <<~SQL
-        SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code
+        SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code, c.uuid
           FROM concept_attribute ca
         INNER JOIN concept_attribute ca2 ON ca.concept_id = ca2.concept_id
           AND ca2.attribute_type_id = #{ConceptAttributeType.nlims_code.concept_attribute_type_id}
+        INNER JOIN concept c ON c.concept_id = ca.concept_id
         WHERE ca.attribute_type_id = #{ConceptAttributeType.test_catalogue_name.concept_attribute_type_id}
         AND ca.concept_id IN (#{concept_set.pluck(:concept_id).push(0).join(',')})
         GROUP BY ca.concept_id
@@ -114,15 +118,16 @@ module Lab
       measures = ConceptSet.find_members_by_name(Lab::Metadata::TEST_RESULT_INDICATOR_CONCEPT_NAME)
                            .select(:concept_id)
 
-      sets = ConceptSet.where(concept_set: measures, concept_id: test)
+      sets = ConceptSet.where(concept_set: test, concept_id: measures)
 
       return ActiveRecord::Base.connection.select_all <<~SQL
-        SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code
+        SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code, c.uuid
           FROM concept_attribute ca
           INNER JOIN concept_attribute ca2 ON ca.concept_id = ca2.concept_id
             AND ca2.attribute_type_id = #{ConceptAttributeType.nlims_code.concept_attribute_type_id}
+          INNER JOIN concept c ON c.concept_id = ca.concept_id
           WHERE ca.attribute_type_id = #{ConceptAttributeType.test_catalogue_name.concept_attribute_type_id}
-          AND ca.concept_id IN (#{sets.pluck(:concept_set).push(0).join(',')})
+          AND ca.concept_id IN (#{sets.pluck(:concept_id).push(0).join(',')})
           GROUP BY ca.concept_id
       SQL
     end

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

@@ -4,20 +4,22 @@ module Lab
   module Lims
     # This class is responsible for handling the acknowledgement of lab orders
     class AcknowledgementWorker
-      attr_reader :lims_api
+      attr_reader :lims_api, :start_date
 
       include Utils # for logger
 
       SECONDS_TO_WAIT_FOR_ORDERS = 30
 
-      def initialize(lims_api)
+      def initialize(lims_api, start_date: nil)
         @lims_api = lims_api
+        @start_date = start_date
       end
 
       def push_acknowledgement(batch_size: 1000, wait: false)
         loop do
           logger.info('Looking for new acknowledgements to push to LIMS...')
-          acknowledgements = Lab::AcknowledgementService.acknowledgements_pending_sync(batch_size).all
+          acknowledgements = Lab::AcknowledgementService.acknowledgements_pending_sync(batch_size,
+                                                                                       start_date: start_date).all
 
           logger.debug("Found #{acknowledgements.size} acknowledgements...")
           acknowledgements.each do |acknowledgement|

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

@@ -74,8 +74,8 @@ 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))
@@ -510,43 +510,47 @@ 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

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

@@ -109,6 +109,7 @@ module Lab
         end
 
         def format_sample_type(name)
+          return 'not_specified' if name.nil?
           return 'not_specified' if name.casecmp?('Unknown')
 
           return 'CSF' if name.casecmp?('Cerebrospinal Fluid')

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])

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

@@ -5,15 +5,16 @@ module Lab
     ##
     # Pushes all local orders to a LIMS Api object.
     class PushWorker
-      attr_reader :lims_api
+      attr_reader :lims_api, :start_date
 
       include Utils # for logger
 
       SECONDS_TO_WAIT_FOR_ORDERS = 30
       START_DATE = Time.parse('2024-09-03').freeze
 
-      def initialize(lims_api)
+      def initialize(lims_api, start_date: nil)
         @lims_api = lims_api
+        @start_date = start_date
       end
 
       def push_orders(batch_size: 1000, wait: false)
@@ -81,8 +82,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)
@@ -100,10 +101,16 @@ module Lab
 
       def new_orders
         Rails.logger.debug('Looking for new orders that need to be created in LIMS...')
-        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)
+        query = Lab::LabOrder.where.not(order_id: Lab::LimsOrderMapping.all.select(:order_id))
+                             .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)
       end
 
       def updated_orders
@@ -111,23 +118,26 @@ 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 lab_lims_order_mappings.result_push_status = 0',
+                     .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',
                             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...')
-        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('orders.date_created >= ?', start_date) if start_date
+        orders.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
+      def self.start(start_date: nil)
         User.current = Utils.lab_user
 
-        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?
+        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?
 
         Process.waitall
       end
 
-      def self.start_push_worker
+      def self.start_push_worker(start_date: nil)
         start_worker('push_worker') do
-          worker = PushWorker.new(lims_api)
+          worker = PushWorker.new(lims_api, start_date: start_date)
 
           worker.push_orders # (wait: true)
         end
       end
 
-      def self.start_acknowledgement_worker
+      def self.start_acknowledgement_worker(start_date: nil)
         start_worker('acknowledgement_worker') do
-          worker = AcknowledgementWorker.new(lims_api)
+          worker = AcknowledgementWorker.new(lims_api, start_date: start_date)
           worker.push_acknowledgement
         end
       end
 
-      def self.start_pull_worker
+      def self.start_pull_worker(start_date: nil)
         start_worker('pull_worker') do
-          worker = PullWorker.new(lims_api)
+          worker = PullWorker.new(lims_api, start_date: start_date)
 
           worker.pull_orders
         end
       end
 
-      def self.start_realtime_pull_worker
+      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))
+          worker = PullWorker.new(Lims::Api::WsApi.new(Lab::Lims::Config.updates_socket), start_date: start_date)
 
           worker.pull_orders
         end

data/app/services/lab/orders_service.rb

@@ -260,7 +260,8 @@ module Lab
         order.date_created = params[:date]&.to_date || Date.today if order.respond_to?(:date_created)
         order.start_date = params[:date]&.to_date || Date.today if order.respond_to?(:start_date)
         order.auto_expire_date = params[:end_date]
-        order.comment_to_fulfiller = params[:comment_to_fulfiller] if params[:comment_to_fulfiller]
+        # Note: comment_to_fulfiller is a has_one association, not a field
+        # It will be created via add_comment_to_fulfiller method
         order.accession_number = access_number
         order.orderer = User.current&.user_id
 

data/app/services/lab/results_service.rb

@@ -43,7 +43,11 @@ module Lab
         ActiveRecord::Base.connection.commit_db_transaction
 
         # Execute job synchronously
-        ProcessLabResultJob.perform_now(results_obs.id, serializer, result_enter_by)
+        begin
+          ProcessLabResultJob.perform_now(results_obs.id, serializer, result_enter_by)
+        rescue StandardError => e
+          Rails.logger.error("Lab::ResultsService: Error processing lab result job for test #{test_id}: #{e.message}")
+        end
 
         Rails.logger.info("Lab::ResultsService: Result created for test #{test_id} #{serializer}")
         serializer

data/lib/lab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lab
-  VERSION = '2.1.8.4'
+  VERSION = '2.1.8.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: his_emr_api_lab
 version: !ruby/object:Gem::Version
-  version: 2.1.8.4
+  version: 2.1.8.6
 platform: ruby
 authors:
 - Elizabeth Glaser Pediatric Foundation Malawi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-13 00:00:00.000000000 Z
+date: 2026-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: couchrest