his_emr_api_lab 2.1.0 → 2.1.2

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

@@ -50,10 +50,15 @@ module Lab
           30 # Seconds
         end
 
+        def config_file_name
+          # if nlims.yml exists return it, else return application.yml
+          File.exist?(Rails.root.join('config', 'nlims.yml')) ? 'nlims.yml' : 'application.yml'
+        end
+
         ##
         # Returns LIMS' application.yml configuration file
         def application
-          @application ||= YAML.load_file(find_config_path('application.yml'))
+          @application ||= YAML.load_file(find_config_path(config_file_name))
         end
 
         ##
@@ -65,7 +70,7 @@ module Lab
         private
 
         def emr_api_application(param, fallback = nil)
-          @emr_api_application ||= YAML.load_file(Rails.root.join('config', 'application.yml'))
+          @emr_api_application ||= YAML.load_file(Rails.root.join('config', config_file_name))
 
           @emr_api_application.fetch(param) do
             raise ConfigNotFound, "Missing config param: #{param}" unless fallback

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

@@ -2,11 +2,12 @@
 
 module Lab
   module Lims
-    class Exceptions < StandardError; end
-    class LimsException < StandardError; end
-    class DuplicateNHID < LimsException; end
-    class MissingAccessionNumber < LimsException; end
-    class UnknownSpecimenType < LimsException; end
-    class UnknownTestType < LimsException; end
+    module Exceptions
+      class LimsException < StandardError; end
+      class DuplicateNHID < LimsException; end
+      class MissingAccessionNumber < LimsException; end
+      class UnknownSpecimenType < LimsException; end
+      class UnknownTestType < LimsException; end
+    end
   end
 end

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

@@ -29,7 +29,7 @@ require 'lab/lab_test'
 require 'lab/lims_order_mapping'
 require 'lab/lims_failed_import'
 
-require_relative 'api/couchdb_api'
+require_relative 'api/couch_db_api'
 require_relative 'config'
 require_relative 'pull_worker'
 require_relative 'utils'
@@ -60,8 +60,8 @@ module Lab
       ##
       # A Lab::Lims::Api object that supports crawling of a LIMS CouchDB instance.
       class CouchDbMigratorApi < Lab::Lims::Api::CouchdbApi
-        def initialize(*args, processes: 1, on_merge_processes: nil, **kwargs)
-          super(*args, **kwargs)
+        def initialize(*, processes: 1, on_merge_processes: nil, **)
+          super(*, **)
 
           @processes = processes
           @on_merge_processes = on_merge_processes

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

@@ -17,7 +17,7 @@ module Lab
           accession_number: self['tracking_number'],
           patient_id:,
           specimen: { concept_id: specimen_type_id },
-          tests: self['tests']&.map { |test| { concept_id: test_type_id(test) } },
+          tests: self['tests_map']&.map { |test| { concept_id: test.concept_id } },
           requesting_clinician:,
           date: start_date,
           target_lab: facility_name(self['receiving_facility']),

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

@@ -14,16 +14,20 @@ module Lab
 
         def serialize_order(order)
           serialized_order = Lims::Utils.structify(Lab::LabOrderSerializer.serialize_order(order))
-
           Lims::OrderDto.new(
-            _id: Lab::LimsOrderMapping.find_by(order:)&.lims_id || serialized_order.accession_number,
+            _id: Lab::LimsOrderMapping.find_by(order: order)&.lims_id || serialized_order.accession_number,
             tracking_number: serialized_order.accession_number,
             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: 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),
+              nlims_code: Concept.find(serialized_order.specimen.concept_id).nlims_code
+            },
             sample_status: format_sample_status(serialized_order.specimen.name),
             sample_statuses: format_sample_status_trail(order),
             test_statuses: format_test_status_trail(order),
@@ -32,7 +36,8 @@ module Lab
             priority: format_sample_priority(serialized_order.reason_for_test.name),
             date_created: serialized_order.order_date,
             test_results: format_test_results(serialized_order),
-            type: 'Order'
+            type: 'Order',
+            clinical_history: serialized_order.comment_to_fulfiller
           )
         end
 
@@ -81,6 +86,8 @@ module Lab
           return nil if regimen_data.blank?
 
           regimen_data['regimen']
+        rescue StandardError
+          nil
         end
 
         def find_arv_number(patient_id)
@@ -97,6 +104,8 @@ module Lab
           return nil if start_date.blank?
 
           start_date['earliest_date']
+        rescue StandardError
+          nil
         end
 
         def format_sample_type(name)
@@ -114,9 +123,12 @@ module Lab
         def format_sample_status_trail(order)
           return [] if order.concept_id == ConceptName.find_by_name!('Unknown').concept_id
 
-          user = User.find(order.discontinued_by || order.creator)
+          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
+          drawn_date = order.discontinued_date || order.start_date if ['discontinued_date', 'start_date'].all? { |column| order.respond_to?(column) }
+          drawn_date ||= order.date_created
 
           [
             drawn_date.strftime('%Y%m%d%H%M%S') => {
@@ -132,7 +144,7 @@ module Lab
         end
 
         def format_test_status_trail(order)
-          tests = order.voided.zero? ? order.tests : Lab::LabOrderSerializer.voided_tests(order)
+          tests = order.voided ? order.tests : Lab::LabOrderSerializer.voided_tests(order)
 
           tests.each_with_object({}) do |test, trail|
             test_name = format_test_name(ConceptName.find_by_concept_id!(test.value_coded).name)
@@ -168,7 +180,13 @@ module Lab
           order.tests&.each_with_object({}) do |test, results|
             next if test.result.nil? || test.result.empty?
 
-            test_creator = User.find(Observation.find(test.result.first.id).creator)
+            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
+
+            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)] = {
@@ -184,6 +202,9 @@ module Lab
                 id: test_creator.username
               }
             }
+          rescue ActiveRecord::RecordNotFound => e
+            Rails.logger.error("Failed to format test results for test #{test.name} in order #{order.accession_number}: #{e.message}")
+            next
           end
         end
 

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

@@ -23,7 +23,7 @@ module Lab
         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])
+          patient = find_patient_by_nhid(order_dto[:patient][:id], order_dto[:tracking_number])
           unless patient
             logger.debug("Discarding order: Non local patient ##{order_dto[:patient][:id]} on order ##{order_dto[:tracking_number]}")
             order_rejected(order_dto, "Patient NPID, '#{order_dto[:patient][:id]}', didn't match any local NPIDs")
@@ -58,7 +58,7 @@ module Lab
       end
 
       def process_order(order_dto)
-        patient = find_patient_by_nhid(order_dto[:patient][:id])
+        patient = find_patient_by_nhid(order_dto[:patient][:id], order_dto[:tracking_number])
         unless patient
           logger.debug("Discarding order: Non local patient ##{order_dto[:patient][:id]} on order ##{order_dto[:tracking_number]}")
           order_rejected(order_dto, "Patient NPID, '#{order_dto[:patient][:id]}', didn't match any local NPIDs")
@@ -107,7 +107,7 @@ module Lab
 
       private
 
-      def find_patient_by_nhid(nhid)
+      def find_patient_by_nhid(nhid, accession_number)
         national_id_type = PatientIdentifierType.where(name: ['National id', 'Old Identification Number'])
         identifiers = PatientIdentifier.where(type: national_id_type, identifier: nhid)
                                        .joins('INNER JOIN person ON person.person_id = patient_identifier.patient_id AND person.voided  = 0')
@@ -126,10 +126,10 @@ module Lab
         patients = Patient.where(patient_id: identifiers.select(:patient_id))
                           .distinct(:patient_id)
                           .all
+        order = Order.find_by(patient_id: patients.select(:patient_id), accession_number: accession_number)
+        raise Lab::Lims::LimsException, "Order #{accession_number} does not exists for patient #{nhid}" if order.nil?
 
-        raise Lab::Lims::DuplicateNHID, "Duplicate National Health ID: #{nhid}" if patients.size > 1
-
-        patients.first
+        order.patient
       end
 
       ##

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

@@ -10,6 +10,7 @@ module Lab
       include Utils # for logger
 
       SECONDS_TO_WAIT_FOR_ORDERS = 30
+      START_DATE = Time.parse('2024-09-03').freeze
 
       def initialize(lims_api)
         @lims_api = lims_api
@@ -23,8 +24,6 @@ module Lab
           logger.debug("Found #{orders.size} orders...")
           orders.each do |order|
             push_order(order)
-          rescue GatewayError => e
-            logger.error("Failed to push order ##{order.accession_number}: #{e.class} - #{e.message}")
           rescue StandardError => e
             logger.error("Failed to push order ##{order.id}: #{order&.accession_number} : #{e.class} - #{e.message}")
           end
@@ -53,7 +52,7 @@ module Lab
 
         ActiveRecord::Base.transaction do
           if mapping && !order.voided.zero?
-            Rails.logger.info("Deleting order ##{order_dto[:accession_number]} from LIMS")
+            Rails.logger.info("Deleting order ##{order_dto['accession_number']} from LIMS")
             lims_api.delete_order(mapping.lims_id, order_dto)
             mapping.destroy
           elsif mapping
@@ -103,6 +102,7 @@ module Lab
         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)
       end
 

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

@@ -47,10 +47,9 @@ module Lab
         return user if user
 
         god_user = User.first
-
-        person = Person.create!(creator: god_user.user_id)
-        PersonName.create!(person:, given_name: 'Lab', family_name: 'Daemon', creator: god_user.user_id)
-
+        User.current = god_user
+        person = Person.create!(creator: god_user.user_id, birthdate: '1980-01-01')
+        PersonName.create!(person: person, given_name: 'Lab', family_name: 'Daemon', creator: god_user.user_id)
         User.create!(username: 'lab_daemon', person:, creator: god_user.user_id)
       end
 

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

@@ -2,7 +2,7 @@
 
 require 'logger_multiplexor'
 
-require_relative 'api/couchdb_api'
+# require_relative 'api/couchdb_api'
 
 module Lab
   module Lims
@@ -13,7 +13,7 @@ module Lab
         User.current = Utils.lab_user
 
         fork(&method(:start_push_worker))
-        # fork(&method(:start_pull_worker))
+        fork(&method(:start_pull_worker))
         fork(&method(:start_acknowledgement_worker))
         fork(&method(:start_realtime_pull_worker)) if realtime_updates_enabled?
 

data/app/services/lab/metadata.rb

@@ -5,6 +5,7 @@ module Lab
     # Concepts
     REASON_FOR_TEST_CONCEPT_NAME = 'Reason for test'
     REQUESTING_CLINICIAN_CONCEPT_NAME = 'Person making request'
+    COMMENT_TO_FULFILLER_CONCEPT_NAME = 'Comment to fulfiller'
     SPECIMEN_TYPE_CONCEPT_NAME = 'Specimen type'
     TARGET_LAB_CONCEPT_NAME = 'Lab'
     TEST_RESULT_CONCEPT_NAME = 'Lab test result'
@@ -12,12 +13,15 @@ module Lab
     TEST_TYPE_CONCEPT_NAME = 'Test type'
     LAB_ORDER_STATUS_CONCEPT_NAME = 'lab order status'
     UNKNOWN_SPECIMEN = 'Unknown'
+    VISIT_TYPE_UUID = '8a4a4488-c2cc-11de-8d13-0010c6dffd0f'
+    TEST_METHOD_CONCEPT_NAME = 'Recommended test method'
 
     # Encounter
     ENCOUNTER_TYPE_NAME = 'Lab'
 
     # Order types
     ORDER_TYPE_NAME = 'Lab'
+    HTS_ORDER_TYPE_NAME = 'HTS Lab'
 
     # Programs
     LAB_PROGRAM_NAME = 'Laboratory Program'

data/app/services/lab/notification_service.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# notification service
+class Lab::NotificationService
+  # this gets all uncleared notifications of the user
+  def uncleared
+    NotificationAlert.joins(:notification_alert_recipients).where(
+      'notification_alert_recipient.user_id = ?', User.current.user_id
+    )
+  end
+
+  def clear(alert_id)
+    alert = NotificationAlert.find(alert_id)
+    # update the notification alert recipient to cleared and read only for the current user
+    alert.notification_alert_recipients.where(user_id: User.current.user_id).update_all(cleared: true, alert_read: true)
+  end
+
+  # this updates the notification to read
+  def read(alerts)
+    alerts.each do |alert|
+      notification = NotificationAlertRecipient.where(user_id: User.current.user_id, alert_id: alert,
+                                                      alert_read: false).first
+      next if notification.blank?
+
+      notification.alert_read = true
+      notification.save
+    end
+  end
+
+  def create_notification(alert_type, alert_message)
+    return if alert_type != 'LIMS'
+
+    lab = User.find_by(username: 'lab_daemon')
+    ActiveRecord::Base.transaction do
+      alert = NotificationAlert.create!(text: alert_message.to_json, date_to_expire: Time.now + not_period.days,
+                                        creator: lab, changed_by: lab, date_created: Time.now)
+      notify(alert, User.joins(:roles).uniq)
+      # ActionCable.server.broadcast('nlims_channel', alert)
+    end
+  end
+
+  def not_period
+    result = GlobalProperty.where(property: 'notification.period')&.first
+    return result.property_value.to_i if result.present?
+
+    7 # default to 7 days
+  end
+
+  def notify(notification_alert, recipients)
+    recipients.each do |recipient|
+      recipient.notification_alert_recipients.create(
+        alert_id: notification_alert.id
+      )
+    end
+  end
+
+  def notify_all(notification_alert, users)
+    users.each do |user|
+      user.notification_alert_recipients.create(
+        alert_id: notification_alert.id
+      )
+    end
+  end
+
+  def notify_all_users(notification_alert)
+    User.all.each do |user|
+      user.notification_alert_recipients.create!(
+        alert_id: notification_alert.id
+      )
+    end
+  end
+end

data/app/services/lab/orders_search_service.rb

@@ -7,12 +7,18 @@ module Lab
       def find_orders(filters)
         extra_filters = pop_filters(filters, :date, :end_date, :status)
 
+        uuid = filters.delete(:patient)
+        patient = Patient.find(uuid) if uuid
+
+        filters.merge!(patient_id: patient.id) if patient
+
         orders = Lab::LabOrder.prefetch_relationships
                               .where(filters)
-                              .order(start_date: :desc)
+        orders = orders.order(start_date: :desc) if Order.column_names.include?('start_date')
+        orders = orders.order(date_created: :desc) unless Order.column_names.include?('start_date')
 
-        orders = filter_orders_by_status(orders, **pop_filters(extra_filters, :status))
-        orders = filter_orders_by_date(orders, **extra_filters)
+        orders = filter_orders_by_status(orders: orders, status: extra_filters[:status])
+        orders = filter_orders_by_date(orders: orders, date: extra_filters[:date], end_date: extra_filters[:end_date])
 
         orders.map { |order| Lab::LabOrderSerializer.serialize_order(order) }
       end
@@ -27,7 +33,7 @@ module Lab
         query
       end
 
-      def filter_orders_by_date(orders, date: nil, end_date: nil)
+      def filter_orders_by_date(orders:, date: nil, end_date: nil)
         date = date&.to_date
         end_date = end_date&.to_date
 
@@ -40,7 +46,7 @@ module Lab
         orders
       end
 
-      def filter_orders_by_status(orders, status: nil)
+      def filter_orders_by_status(orders:, status: nil)
         case status&.downcase
         when 'ordered' then orders.where(concept_id: unknown_concept_id)
         when 'drawn' then orders.where.not(concept_id: unknown_concept_id)

data/app/services/lab/orders_service.rb

@@ -58,16 +58,28 @@ module Lab
 
           order = create_order(encounter, order_params)
 
+          attach_test_method(order, order_params) if order_params[:test_method]
+
           Lab::TestsService.create_tests(order, order_params[:date], order_params[:tests])
 
           Lab::LabOrderSerializer.serialize_order(
             order, requesting_clinician: add_requesting_clinician(order, order_params),
                    reason_for_test: add_reason_for_test(order, order_params),
-                   target_lab: add_target_lab(order, order_params)
+                   target_lab: add_target_lab(order, order_params),
+                   comment_to_fulfiller: add_comment_to_fulfiller(order, order_params)
           )
         end
       end
 
+      def attach_test_method(order, order_params)
+        create_order_observation(
+          order,
+          Lab::Metadata::TEST_METHOD_CONCEPT_NAME,
+          order_params[:date],
+          value_coded: order_params[:test_method]
+        )
+      end
+
       def update_order(order_id, params)
         specimen_id = params.dig(:specimen, :concept_id)
         raise ::InvalidParameterError, 'Specimen concept_id is required' unless specimen_id
@@ -86,20 +98,23 @@ module Lab
                         discontinued_reason_non_coded: 'Sample drawn/updated')
         end
 
-        if params[:reason_for_test_id]
+        reason_for_test = params[:reason_for_test] || params[:reason_for_test_id]
+
+        if reason_for_test
           Rails.logger.debug("Updating reason for test on order ##{order.order_id}")
-          update_reason_for_test(order, params[:reason_for_test_id])
+          update_reason_for_test(order, Concept.find(reason_for_test)&.id, force_update: params.fetch('force_update', false))
         end
 
         Lab::LabOrderSerializer.serialize_order(order)
       end
 
       def void_order(order_id, reason)
-        order = Lab::LabOrder.includes(%i[requesting_clinician reason_for_test target_lab], tests: [:result])
+        order = Lab::LabOrder.includes(%i[requesting_clinician reason_for_test target_lab comment_to_fulfiller], tests: [:result])
                              .find(order_id)
 
         order.requesting_clinician&.void(reason)
         order.reason_for_test&.void(reason)
+        order.comment_to_fulfiller&.void(reason)
         order.target_lab&.void(reason)
 
         order.tests.each { |test| test.void(reason) }
@@ -160,13 +175,13 @@ module Lab
       def create_rejection_notification(order_params)
         order = find_order order_params['tracking_number']
         data = { 'type': 'LIMS',
+                 'specimen': ConceptName.find_by(concept_id: order.concept_id)&.name,
                  'accession_number': order&.accession_number,
                  'order_date': order&.start_date,
                  'arv_number': find_arv_number(order.patient_id),
                  'patient_id': result.person_id,
                  'ordered_by': order&.provider&.person&.name,
-                 'rejection_reason': order_params['comments']
-                }.as_json
+                 'rejection_reason': order_params['comments'] }.as_json
         NotificationService.new.create_notification('LIMS', data)
       end
 
@@ -207,35 +222,50 @@ module Lab
       # a 'Lab' encounter is created using the provided program_id and
       # patient_id.
       def find_encounter(order_params)
-        return Encounter.find(order_params[:encounter_id]) if order_params[:encounter_id]
-
-        raise InvalidParameterError, 'encounter_id or patient_id required' unless order_params[:patient_id]
-
-        program_id = order_params[:program_id] || Program.find_by_name!(Lab::Metadata::LAB_PROGRAM_NAME).program_id
-
-        Encounter.create!(
-          patient_id: order_params[:patient_id],
-          program_id:,
-          type: EncounterType.find_by_name!(Lab::Metadata::ENCOUNTER_TYPE_NAME),
-          encounter_datetime: order_params[:date] || Date.today,
-          provider_id: order_params[:provider_id] || User.current.person.person_id
-        )
+        encounter_id = order_params[:encounter_id] || order_params[:encounter]
+        patient_id = order_params[:patient_id] || order_params[:patient]
+        visit = order_params[:visit]
+
+        return Encounter.find(encounter_id) if order_params[:encounter] || order_params[:encounter_id]
+        raise StandardError, 'encounter_id|uuid or patient_id|uuid required' unless order_params[:patient]
+
+        encounter = Encounter.new
+        encounter.patient = Patient.find(patient_id)
+        encounter.encounter_type = EncounterType.find_by_name!(Lab::Metadata::ENCOUNTER_TYPE_NAME)
+        encounter.encounter_datetime = order_params[:date] || Date.today
+        encounter.visit = Visit.find_by_uuid(visit) if Encounter.column_names.include?('visit_id')
+        encounter.provider_id = User.current&.person.id if Encounter.column_names.include?('provider_id')
+        encounter.program_id = order_params[:program_id] if Encounter.column_names.include?('program_id') && order_params[:program_id].present?
+        encounter.save!
+        encounter.reload
       end
 
       def create_order(encounter, params)
         access_number = params[:accession_number] || next_accession_number(params[:date]&.to_date || Date.today)
         raise 'Accession Number cannot be blank' unless access_number.present?
         raise 'Accession cannot be this short' unless access_number.length > 6
-        Lab::LabOrder.create!(
-          order_type: OrderType.find_by_name!(Lab::Metadata::ORDER_TYPE_NAME),
-          concept_id: params.dig(:specimen, :concept_id) || unknown_concept_id,
-          encounter_id: encounter.encounter_id,
-          patient_id: encounter.patient_id,
-          start_date: params[:date]&.to_date || Date.today,
-          auto_expire_date: params[:end_date],
-          accession_number: access_number,
-          orderer: User.current&.user_id
-        )
+
+        concept = params.dig(:specimen, :concept)
+        concept ||= params.dig(:specimen, :concept_id)
+
+        order_type = nil
+        order_type = OrderType.find_by_order_type_id!(params[:order_type_id])&.id if params[:order_type_id].present?
+
+        order = Lab::LabOrder.new
+        order.order_type_id = order_type || OrderType.find_by_name!(Lab::Metadata::ORDER_TYPE_NAME).id
+        order.concept_id = Concept.find(concept)&.id
+        order.encounter_id = encounter.id
+        order.patient_id = encounter.patient.id
+        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]
+        order.accession_number = access_number
+        order.orderer = User.current&.user_id
+
+        order.save!
+
+        order.reload
       end
 
       def accession_number_exists?(accession_number)
@@ -262,16 +292,28 @@ module Lab
         )
       end
 
+      def add_comment_to_fulfiller(order, params)
+        create_order_observation(
+          order,
+          Lab::Metadata::COMMENT_TO_FULFILLER_CONCEPT_NAME,
+          params[:date],
+          value_text: params['comment_to_fulfiller']
+        )
+      end
+
       ##
       # Attach a reason for the order/test
       #
       # Examples of reasons include: Routine, Targeted, Confirmatory, Repeat, or Stat.
       def add_reason_for_test(order, params)
+        reason = params[:reason_for_test_id] || params[:reason_for_test]
+
+        reason = Concept.find(reason)
         create_order_observation(
           order,
           Lab::Metadata::REASON_FOR_TEST_CONCEPT_NAME,
           params[:date],
-          value_coded: params[:reason_for_test_id]
+          value_coded: reason
         )
       end
 
@@ -288,14 +330,16 @@ module Lab
         )
       end
 
-      def create_order_observation(order, concept_name, date, **)
+      def create_order_observation(order, concept_name, date, **values)
+        creator = User.find_by(username: 'lab_daemon')
+        User.current ||= creator
         Observation.create!(
           order:,
           encounter_id: order.encounter_id,
           person_id: order.patient_id,
           concept_id: ConceptName.find_by_name!(concept_name).concept_id,
           obs_datetime: date&.to_time || Time.now,
-          **
+          **values
         )
       end
 
@@ -304,18 +348,20 @@ module Lab
       end
 
       def unknown_concept_id
-        ConceptName.find_by_name!('Unknown').concept_id
+        ConceptName.find_by_name!('Unknown').concept
       end
 
-      def update_reason_for_test(order, concept_id)
+      def update_reason_for_test(order, concept_id, force_update: false)
         raise InvalidParameterError, "Reason for test can't be blank" if concept_id.blank?
 
         return if order.reason_for_test&.value_coded == concept_id
 
-        raise InvalidParameterError, "Can't change reason for test once set" if order.reason_for_test&.value_coded
+        raise InvalidParameterError, "Can't change reason for test once set" if order.reason_for_test&.value_coded && !force_update
 
         order.reason_for_test&.delete
-        add_reason_for_test(order, date: order.start_date, reason_for_test_id: concept_id)
+        date = order.start_date if order.respond_to?(:start_date)
+        date ||= order.date_created
+        add_reason_for_test(order, date: date, reason_for_test_id: concept_id)
       end
 
       def void_order_status(order, concept)