his_emr_api_lab 2.4.8.pre.alpha → 2.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c976558db9507288b37c309d50e9b45ccb70b9848483c86c980e605906464823
-  data.tar.gz: 88223e508a7f67c51afa7c40f6b2fb2d758c9afe868c32e8a56dd44b567db8f9
+  metadata.gz: 2f0e2b1fd0f7372571d684a23a529651631e55a271d1355aa1d12f8b7d2a85d5
+  data.tar.gz: 6509d471a8f57e1108430e3d6e08a4308b5bca2e0eb386d1088534f0c0863856
 SHA512:
-  metadata.gz: 357768b64d3e2bd5308e71816b7e38f17883a504376a41275bd609f06d66d5ec21fa51ff9ce0734a6abce99b1aeb103dec484a87623e45f1a61e9bcac76a4c3e
-  data.tar.gz: 7e27bf14bc5ece4ab4a4a55145d8ec3492c7b677f7bfd40530fb978cd40492b72579ccea8c4023fd64cc3976d949ddc37993af8195cbdfcbd90f25a0ecc87bdd
+  metadata.gz: 2500b6aa2b1cc75bc8476a4ed68576faf0156cc7f836b7fd3039606db135c05672f957fe4188d69f994b9fc54c952fb39974dcd398dee0376af32e78b5f9f0ab
+  data.tar.gz: f74c867864d8c77e8b73ec31b8ac0dd82d5b6d77d4c6152d32cbf3c010e909d24c844839153d4670f14bcfaa9db1e45de6f5d767176d70b262321eec8603b9f4

data/app/controllers/lab/orders_controller.rb

@@ -22,8 +22,8 @@ module Lab
 
     def update
       specimen = params.require(:specimen).slice(:concept_id)
-      order = OrdersService.update_order(params[:id], specimen:, force_update: params[:force_update])
-
+      order = OrdersService.update_order(params[:id], specimen:, force_update: params[:force_update], date: params[:date])
+      
       begin
         Lab::PushOrderJob.perform_later(order.fetch(:order_id))
       rescue StandardError => e

data/app/models/lab/lab_order.rb

@@ -66,6 +66,10 @@ module Lab
         .where.not(concept_id: ConceptName.where(name: 'Tests ordered').select(:concept_id))
     end
 
+    # Only checked when start_date is set or changed, so existing future-dated
+    # orders can still be voided or updated during clean-up.
+    validate :start_date_cannot_be_in_the_future, if: :will_save_change_to_start_date?
+
     scope :drawn, -> { where.not(concept_id: ConceptName.where(name: 'Unknown').select(:concept_id)) }
     scope :not_drawn, -> { where(concept_id: ConceptName.where(name: 'Unknown').select(:concept_id)) }
 
@@ -78,5 +82,13 @@ module Lab
               :comment_to_fulfiller,
               :tests)
     end
+
+    # Allows up to tomorrow to cover timezone differences, matching
+    # Lab::Lims::Utils.parse_date.
+    def start_date_cannot_be_in_the_future
+      return if start_date.blank? || start_date.to_date <= Date.current + 1.day
+
+      errors.add(:start_date, 'cannot be in the future')
+    end
   end
 end

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

@@ -9,6 +9,7 @@ module Lab
       class UnknownSpecimenType < LimsException; end
       class UnknownTestType < LimsException; end
       class ValidationUnavailable < LimsException; end
+      class InvalidDate < LimsException; end
     end
   end
 end
@@ -21,5 +22,6 @@ module Lab
     class UnknownSpecimenType < LimsException; end
     class UnknownTestType < LimsException; end
     class ValidationUnavailable < LimsException; end
+    class InvalidDate < LimsException; end
   end
 end

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

@@ -12,6 +12,8 @@ module Lab
       include Utils # for logger
 
       LIMS_LOG_PATH = Rails.root.join('log', 'lims')
+      UNMAPPED_ORDER_REASON = 'Order not mapped to LIMS: pull worker does not create orders'
+      DECEASED_PATIENT_REASON = "Order dated after patient's death"
 
       def initialize(lims_api, start_date: nil, accession_numbers: [], patient_id: nil)
         @lims_api = lims_api
@@ -171,47 +173,84 @@ module Lab
         name1.casecmp?(name2)
       end
 
+      ##
+      # Applies a LIMS order to the local order it is mapped to.
+      #
+      # Orders are only ever created in the EMR, never by the pull worker.
+      # find_patient_by_nhid only lets an order through when a local order with
+      # the same accession number already exists, so creating one here would
+      # always produce a duplicate. Orders without a LIMS mapping (e.g. legacy
+      # orders, or new orders the push worker has not sent yet) are skipped and
+      # recorded once in lab_lims_failed_imports for review. So are orders
+      # dated after the patient's death.
+      #
+      # Returns the updated order, or nil if the order was skipped.
       def save_order(patient, order_dto)
         raise MissingAccessionNumber if order_dto[:tracking_number].blank?
 
         logger.info("Importing LIMS order ##{order_dto[:tracking_number]}")
+
+        death_date = death_date_before_order(patient, order_dto)
+        if death_date
+          order_date = lims_order_date(order_dto)
+          logger.warn("Not importing order ##{order_dto[:tracking_number]}: dated #{order_date}, after patient's death on #{death_date}")
+          record_skipped_order(order_dto, DECEASED_PATIENT_REASON, { order_date:, death_date: })
+          return nil
+        end
+
         mapping = find_order_mapping_by_lims_id(order_dto[:_id])
 
+        unless mapping
+          logger.warn("Not creating order ##{order_dto[:tracking_number]} from LIMS: no LIMS mapping for local order")
+          record_skipped_order(order_dto, UNMAPPED_ORDER_REASON)
+          return nil
+        end
+
         ActiveRecord::Base.transaction do
-          if mapping
-            order = update_order(patient, mapping.order_id, order_dto)
-            mapping.update(pulled_at: Time.now)
-          else
-            order = create_order(patient, order_dto)
-            mapping = LimsOrderMapping.create(lims_id: order_dto[:_id],
-                                              order_id: order['id'],
-                                              pulled_at: Time.now,
-                                              revision: order_dto['_rev'])
-          end
+          order = update_order(patient, mapping.order_id, order_dto)
+          mapping.update(pulled_at: Time.now)
 
           order
         end
       end
 
-      def create_order(patient, order_dto)
-        logger.debug("Creating order ##{order_dto['_id']}")
-        params = order_dto.to_order_service_params(patient_id: patient.patient_id)
-        params[:location_id] ||= location_id_for_order_dto(order_dto)
-        order = OrdersService.order_test(params)
+      ##
+      # Returns the patient's death date if the order is dated after it, else nil.
+      #
+      # Orders dated on or before the death date are still imported, so results
+      # for samples drawn before death keep arriving.
+      def death_date_before_order(patient, order_dto)
+        person = Person.unscoped.find_by(person_id: patient.patient_id)
+        return nil unless person && ActiveModel::Type::Boolean.new.cast(person.dead) && person.death_date
+
+        death_date = person.death_date.to_date
+        death_date if lims_order_date(order_dto) > death_date
+      end
 
-        # Extract and save status trails from NLIMS
-        save_status_trails_from_nlims(order, order_dto)
+      def lims_order_date(order_dto)
+        raise LimsException, 'Order missing created date' if order_dto[:date_created].blank?
 
-        # Update results if present
-        update_results(order, order_dto['test_results']) unless order_dto['test_results'].empty?
+        Utils.parse_date(order_dto[:date_created]).to_date
+      end
 
-        order
+      # The REST pull re-selects skipped orders on every run, so each one is
+      # recorded only once instead of adding a row per run.
+      def record_skipped_order(order_dto, reason, diff = nil)
+        LimsFailedImport.find_or_create_by!(lims_id: order_dto[:_id],
+                                            tracking_number: order_dto[:tracking_number],
+                                            reason:) do |failed_import|
+          failed_import.patient_nhid = order_dto.dig(:patient, :id)
+          failed_import.diff = diff&.to_json
+        end
+      rescue StandardError => e
+        logger.error("Failed to record skipped order ##{order_dto[:tracking_number]}: #{e.message}")
       end
 
       def update_order(patient, order_id, order_dto)
         logger.debug("Updating order ##{order_dto['_id']}")
         params = order_dto.to_order_service_params(patient_id: patient.patient_id)
         params[:location_id] ||= Lab::OrderLocationResolver.location_id_for_order_id(order_id, facility_name: order_dto[:sending_facility])
+        keep_local_specimen(order_id, params) unless specimen_update_allowed?(order_id)
         order = OrdersService.update_order(order_id, params.merge(force_update: 'true'))
 
         # Extract and save status trails from NLIMS
@@ -223,6 +262,38 @@ module Lab
         order
       end
 
+      ##
+      # LIMS may only set the specimen of an order whose sample has not been
+      # drawn yet (specimen 'Unknown') and that has no results. Any other order
+      # keeps its local specimen, so a sync can never change or discontinue an
+      # order that has already been drawn or resulted.
+      def specimen_update_allowed?(order_id)
+        order = Lab::LabOrder.unscoped.find(order_id)
+
+        order.concept_id == unknown_specimen_concept_id && !order_has_results?(order_id)
+      end
+
+      def keep_local_specimen(order_id, params)
+        local_specimen_id = Lab::LabOrder.unscoped.find(order_id).concept_id
+        lims_specimen_id = params.dig(:specimen, :concept_id)
+
+        if lims_specimen_id.present? && lims_specimen_id.to_i != local_specimen_id
+          logger.info("Keeping local specimen ##{local_specimen_id} on order ##{order_id}, ignoring LIMS specimen ##{lims_specimen_id}")
+        end
+
+        params[:specimen] = { concept_id: local_specimen_id }
+      end
+
+      def unknown_specimen_concept_id
+        @unknown_specimen_concept_id ||= ConceptName.find_by(name: Lab::Metadata::UNKNOWN_SPECIMEN)&.concept_id
+      end
+
+      def order_has_results?(order_id)
+        result_concept = ConceptName.where(name: Lab::Metadata::TEST_RESULT_CONCEPT_NAME).select(:concept_id)
+
+        Observation.unscoped.where(order_id:, concept_id: result_concept, voided: 0).exists?
+      end
+
       def update_results(order, lims_results)
         logger.debug("Updating results for order ##{order[:accession_number]}: #{lims_results}")
 
@@ -266,12 +337,6 @@ module Lab
         LabTest.unscoped.find_by(order_id:, value_coded: test_concept.concept_id, voided: 0)
       end
 
-      def location_id_for_order_dto(order_dto)
-        local_order = Lab::LabOrder.unscoped.find_by(accession_number: order_dto[:tracking_number])
-
-        Lab::OrderLocationResolver.location_id_for_order(local_order, facility_name: order_dto[:sending_facility])
-      end
-
       def find_measure(_order, indicator_name, value)
         indicator = Utils.find_concept_by_name(indicator_name)
         unless indicator

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

@@ -2,6 +2,8 @@
 
 require 'cgi/util'
 
+require_relative 'exceptions'
+
 module Lab
   module Lims
     ##
@@ -54,6 +56,16 @@ module Lab
         User.create!(username: 'lab_daemon', person:, creator: god_user.user_id)
       end
 
+      # Earliest date accepted from LIMS. Anything older is a corrupted
+      # legacy date (e.g. year 0026 or 18xx), not a real lab order.
+      EARLIEST_VALID_DATE = Date.new(2000, 1, 1)
+
+      ##
+      # Parses a LIMS date, accepting only real calendar dates with a
+      # four-digit year between EARLIEST_VALID_DATE and tomorrow (to allow for
+      # timezone differences). Invalid dates are never guessed at or rewritten:
+      # the fallback date is used if one is given, otherwise InvalidDate is
+      # raised.
       def self.parse_date(str_date, fallback_date = nil)
         str_date = str_date&.to_s
 
@@ -61,21 +73,35 @@ module Lab
 
         return parse_date(fallback_date) if str_date.blank?
 
-        str_date = str_date.gsub(/^00/, '20').gsub(/^180/, '20')
-
-        case str_date
-        when /\d{4}-\d{2}-\d{2}/
-          str_date
-        when /\d{2}-\d{2}-\d{2}/
-          Date.strptime(str_date, '%d-%m-%Y').strftime('%Y-%m-%d')
-        when /(\d{4}\d{2}\d{2})\d+/
-          Date.strptime(str_date, '%Y%m%d').strftime('%Y-%m-%d')
-        when %r{\d{2}/\d{2}/\d{4}}
-          str_date.to_date.to_s
-        else
-          Rails.logger.warn("Invalid date: #{str_date}")
-          parse_date(fallback_date)
+        date = begin
+          case str_date
+          when /\d{4}-\d{2}-\d{2}/
+            str_date
+          when /\d{2}-\d{2}-\d{4}/
+            Date.strptime(str_date, '%d-%m-%Y').strftime('%Y-%m-%d')
+          when /(\d{4}\d{2}\d{2})\d+/
+            Date.strptime(str_date, '%Y%m%d').strftime('%Y-%m-%d')
+          when %r{\d{2}/\d{2}/\d{4}}
+            str_date.to_date.to_s
+          end
+        rescue Date::Error, ArgumentError
+          nil
         end
+
+        return date if valid_date?(date)
+
+        Rails.logger.warn("Invalid date: #{str_date}")
+        raise InvalidDate, "Invalid date: #{str_date}" if fallback_date.blank?
+
+        parse_date(fallback_date)
+      end
+
+      def self.valid_date?(date)
+        return false if date.blank?
+
+        date.to_date.between?(EARLIEST_VALID_DATE, Date.current + 1.day)
+      rescue Date::Error, ArgumentError
+        false
       end
 
       def self.find_concept_by_name(name)

data/app/services/lab/order_location_resolver.rb

@@ -79,6 +79,8 @@ module Lab
     end
 
     def creator_location_for_order(order)
+      return nil unless User.column_names.include?('location_id')
+      
       creator_id = record_creator_id(order)
       return nil if creator_id.blank?
 

data/app/services/lab/orders_service.rb

@@ -249,7 +249,7 @@ module Lab
         orders = Lab::LabOrder.where(order_id: tests.pluck(:order_id))
         data = {
           count: orders.count,
-          last_order_date: Lab::LabOrder.last&.start_date&.to_date,
+          last_order_date: last_order_date(location_id),
           lab_orders: []
         }
         if (include_data.present? && include_data == 'true')
@@ -266,6 +266,19 @@ module Lab
 
       private
 
+      # Without a location this is the latest lab order overall (unchanged behaviour). With a location
+      # it is the latest lab order whose tests were drawn there, so a central EMR serving many sites
+      # reports each site's own last order instead of the latest order across all sites.
+      def last_order_date(location_id)
+        return Lab::LabOrder.last&.start_date&.to_date if location_id.blank?
+
+        order_ids = Lab::LabTest.unscoped
+                                .where(voided: false, location_id:,
+                                       concept: ConceptName.where(name: Lab::Metadata::TEST_TYPE_CONCEPT_NAME))
+                                .select(:order_id)
+        Lab::LabOrder.where(order_id: order_ids).maximum(:start_date)&.to_date
+      end
+
       def create_rejection_notification(order_params)
         order = find_order order_params['tracking_number']
         data = { type: 'LIMS',
@@ -373,7 +386,7 @@ module Lab
       end
 
       def accession_number_exists?(accession_number)
-        Lab::LabOrder.where(accession_number:).exists?
+        Lab::LabOrder.unscoped.where(accession_number:, voided: 0).exists?
       end
 
       def nlims_accession_number_exists?(accession_number)

data/app/services/lab/user_service.rb

@@ -17,6 +17,8 @@ module Lab
       def authenticate_user(username:, password:, user_agent:, request_ip:)
         # Use unscoped for authentication - should not be location-dependent
         user = User.unscoped.find_by_username username
+        return nil if user.nil?
+
         encrypted_pass = Password.new(user.password)
         if encrypted_pass == password
           generate_token(user, user_agent, request_ip)
@@ -24,6 +26,9 @@ module Lab
           # throw authentication error
           nil
         end
+      rescue BCrypt::Errors::InvalidHash
+        # Regular EMR users have SHA passwords; only users created through the LIMS user endpoint can log in here
+        nil
       end
 
       private

data/lib/lab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lab
-  VERSION = '2.4.8-alpha'.freeze
+  VERSION = '2.4.9'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: his_emr_api_lab
 version: !ruby/object:Gem::Version
-  version: 2.4.8.pre.alpha
+  version: 2.4.9
 platform: ruby
 authors:
 - Elizabeth Glaser Pediatric Foundation Malawi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: couchrest
@@ -328,9 +328,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.4.1
 signing_key: