mahis_his_emr_api_lab 1.2.0

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Lab
+  # Search Lab orders.
+  module OrdersSearchService
+    class << self
+      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)
+        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: 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
+
+      def find_orders_without_results(patient_id: nil)
+        results_query = Lab::LabResult.all
+        results_query = results_query.where(person_id: patient_id) if patient_id
+
+        query = Lab::LabOrder.where.not(order_id: results_query.select(:order_id))
+        query = query.where(patient_id: patient_id) if patient_id
+
+        query
+      end
+
+      def filter_orders_by_date(orders:, date: nil, end_date: nil)
+        date = date&.to_date
+        end_date = end_date&.to_date
+
+        return orders.where('start_date BETWEEN ? AND ?', date, end_date + 1.day) if date && end_date
+
+        return orders.where('start_date BETWEEN ? AND ?', date, date + 1.day) if date
+
+        return orders.where('start_date < ?', end_date + 1.day) if end_date
+
+        orders
+      end
+
+      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)
+        else orders
+        end
+      end
+
+      def unknown_concept_id
+        ConceptName.find_by_name!('Unknown').concept_id
+      end
+
+      def pop_filters(params, *filters)
+        filters.each_with_object({}) do |filter, popped_params|
+          next unless params.key?(filter)
+
+          popped_params[filter.to_sym] = params.delete(filter)
+        end
+      end
+
+      def fetch_results(order); end
+    end
+  end
+end

data/app/services/lab/orders_service.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+module Lab
+  ##
+  # Manage lab orders.
+  #
+  # Lab orders are just ordinary openmrs orders with extra metadata that
+  # separates them from other orders. Lab orders have an order type of 'Lab'
+  # with the order's test type as the order's concept. The order's start
+  # date is the day the order is made. Additional information pertaining to
+  # the order is stored as observations that point to the order. The
+  # specimen types, requesting clinician, target lab, and reason for test
+  # are saved as observations to the order. Refer to method #order_test for
+  # more information.
+  module OrdersService
+    class << self
+      ##
+      # Create a lab order.
+      #
+      # Parameters schema:
+      #
+      #     {
+      #       encounter_id: {
+      #         type: :integer,
+      #         required: :false,
+      #         description: 'Attach order to this if program_id and patient_id are not provided'
+      #       },
+      #       program_id: { type: :integer, required: false },
+      #       patient_id: { type: :integer, required: false }
+      #       specimen: { type: :object, properties: { concept_id: :integer }, required: %i[concept_id] },
+      #       test_type_ids: {
+      #         type: :array,
+      #         items: {
+      #           type: :object,
+      #           properties: { concept_id: :integer },
+      #           required: %i[concept_id]
+      #         }
+      #       },
+      #       start_date: { type: :datetime }
+      #       accession_number: { type: :string }
+      #       target_lab: { type: :string },
+      #       reason_for_test_id: { type: :integer },
+      #       requesting_clinician: { type: :string }
+      #     }
+      #
+      # encounter_id: is an ID of the encounter the lab order is to be created under
+      # test_type_id: is a concept_id of the name of test being ordered
+      # specimen_type_id: is a list of IDs for the specimens to be tested (can be ommited)
+      # target_lab: is the name of the lab where test will be carried out
+      # reason_for_test_id: is a concept_id for a (standard) reason of why the test is being carried out
+      # requesting_clinician: Name of the clinician requesting the test (defaults to current user)
+      def order_test(order_params)
+        Order.transaction do
+          encounter = find_encounter(order_params)
+          if order_params[:accession_number].present? && check_tracking_number(order_params[:accession_number])
+            raise 'Accession number already exists'
+          end
+
+          order = create_order(encounter, order_params)
+
+          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)
+          )
+        end
+      end
+
+      def update_order(order_id, params)
+        specimen_id = params.dig(:specimen, :concept_id)
+        raise ::InvalidParameterError, 'Specimen concept_id is required' unless specimen_id
+
+        order = Lab::LabOrder.find(order_id)
+        if order.concept_id != unknown_concept_id && !params[:force_update]&.casecmp?('true')
+          raise ::UnprocessableEntityError, "Can't change order specimen once set"
+        end
+
+        if specimen_id.to_i != order.concept_id
+          Rails.logger.debug("Updating order ##{order.order_id}")
+          order.update!(concept_id: specimen_id,
+                        discontinued: true,
+                        discontinued_by: User.current.user_id,
+                        discontinued_date: params[:date]&.to_date || Time.now,
+                        discontinued_reason_non_coded: 'Sample drawn/updated')
+        end
+
+        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, Concept.find(reason_for_test)&.id)
+        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])
+                             .find(order_id)
+
+        order.requesting_clinician&.void(reason)
+        order.reason_for_test&.void(reason)
+        order.target_lab&.void(reason)
+
+        order.tests.each { |test| test.void(reason) }
+        order.void(reason)
+      end
+
+      def check_tracking_number(tracking_number)
+        accession_number_exists?(tracking_number) || nlims_accession_number_exists?(tracking_number)
+      end
+
+      def update_order_status(order_params)
+        # find the order
+        order = find_order(order_params['tracking_number'])
+        concept = ConceptName.find_by_name Lab::Metadata::LAB_ORDER_STATUS_CONCEPT_NAME
+        ActiveRecord::Base.transaction do
+          void_order_status(order, concept)
+          Observation.create!(
+            person_id: order.patient_id,
+            encounter_id: order.encounter_id,
+            concept_id: concept.concept_id,
+            order_id: order.id,
+            obs_datetime: order_params['status_time'] || Time.now,
+            value_text: order_params['status'],
+            creator: User.current.id
+          )
+        end
+        create_rejection_notification(order_params) if order_params['status'] == 'test-rejected'
+      end
+
+      def update_order_result(order_params)
+        order = find_order(order_params['tracking_number'])
+        order_dto = Lab::Lims::OrderSerializer.serialize_order(order)
+        patch_order_dto_with_lims_results!(order_dto, order_params['results'])
+        Lab::Lims::PullWorker.new(nil).process_order(order_dto)
+      end
+
+      private
+
+      def create_rejection_notification(order_params)
+        order = find_order order_params['tracking_number']
+        data = { 'type': 'LIMS',
+                 '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
+        NotificationService.new.create_notification('LIMS', data)
+      end
+
+      def find_arv_number(patient_id)
+        PatientIdentifier.joins(:type)
+                         .merge(PatientIdentifierType.where(name: 'ARV Number'))
+                         .where(patient_id: patient_id)
+                         .first&.identifier
+      end
+
+      def find_order(tracking_number)
+        Lab::LabOrder.find_by_accession_number(tracking_number)
+      end
+
+      def patch_order_dto_with_lims_results!(order_dto, results)
+        order_dto.merge!(
+          '_id' => order_dto[:tracking_number],
+          '_rev' => 0,
+          'test_results' => results.each_with_object({}) do |result, formatted_results|
+            test_name, measures = result
+            result_date = measures.delete('result_date')
+
+            formatted_results[test_name] = {
+              results: measures.each_with_object({}) do |measure, processed_measures|
+                processed_measures[measure[0]] = { 'result_value' => measure[1] }
+              end,
+              result_date: result_date,
+              result_entered_by: {}
+            }
+          end
+        )
+      end
+
+      ##
+      # Extract an encounter from the given parameters.
+      #
+      # Uses an encounter_id to retrieve an encounter if provided else
+      # a 'Lab' encounter is created using the provided program_id and
+      # patient_id.
+      def find_encounter(order_params)
+        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.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
+
+        concept = params.dig(:specimen, :concept)
+        concept ||= params.dig(:specimen, :concept_id)
+
+        order = Lab::LabOrder.new
+        order.order_type_id = 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.accession_number = access_number
+        order.orderer = User.current&.user_id
+
+        order.save!
+
+        order.reload
+      end
+
+      def accession_number_exists?(accession_number)
+        Lab::LabOrder.where(accession_number: accession_number).exists?
+      end
+
+      def nlims_accession_number_exists?(accession_number)
+        config = YAML.load_file('config/application.yml')
+        return false unless config['lims_api']
+
+        # fetch from the rest api and check if it exists
+        lims_api = Lab::Lims::ApiFactory.create_api
+        lims_api.verify_tracking_number(accession_number).present?
+      end
+
+      ##
+      # Attach the requesting clinician to an order
+      def add_requesting_clinician(order, params)
+        create_order_observation(
+          order,
+          Lab::Metadata::REQUESTING_CLINICIAN_CONCEPT_NAME,
+          params[:date],
+          value_text: params['requesting_clinician']
+        )
+      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: reason
+        )
+      end
+
+      ##
+      # Attach the lab where the test is going to get carried out.
+      def add_target_lab(order, params)
+        return nil unless params['target_lab']
+
+        create_order_observation(
+          order,
+          Lab::Metadata::TARGET_LAB_CONCEPT_NAME,
+          params[:date],
+          value_text: params['target_lab']
+        )
+      end
+
+      def create_order_observation(order, concept_name, date, **values)
+        Observation.create!(
+          order: 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
+
+      def next_accession_number(date = nil)
+        Lab::AccessionNumberService.next_accession_number(date)
+      end
+
+      def unknown_concept_id
+        ConceptName.find_by_name!('Unknown').concept
+      end
+
+      def update_reason_for_test(order, concept_id)
+        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
+
+        order.reason_for_test&.delete
+        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)
+        Observation.where(order_id: order.id, concept_id: concept.concept_id).each do |obs|
+          obs.void('New Status Received from LIMS')
+        end
+      end
+    end
+  end
+end

data/app/services/lab/results_service.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Lab
+  module ResultsService
+    class << self
+      ##
+      # Attach results to a test
+      #
+      # Params:
+      #   test_id: The tests id (maps to obs_id of the test's observation in OpenMRS)
+      #   params: A hash comprising the following fields
+      #     - encounter_id: Encounter to create result under (can be ommitted but provider_id has to specified)
+      #     - provider_id: Specify a provider for an encounter the result is going to be created under
+      #     - date: Retrospective date when the result was received (can be ommitted, defaults to today)
+      #     - measures: An array of measures. A measure is an object of the following structure
+      #         - indicator: An object that has a concept_id field (concept_id of the indicator)
+      #         - value_type: An enum that's limited to 'numeric', 'boolean', 'text', and 'coded'
+      #   result_enter_by: A string that specifies who created the result
+      def create_results(test_id, params, result_enter_by = 'LIMS')
+        serializer = {}
+        results_obs = {}
+        ActiveRecord::Base.transaction do
+          test = Lab::LabTest.find(test_id) rescue nil
+          test = Lab::LabTest.find_by_uuid(test_id) if test.blank?
+          encounter = find_encounter(test, encounter_id: params[:encounter_id],
+                                           encounter_uuid: params[:encounter],
+                                           date: params[:date]&.to_date,
+                                           provider_id: params[:provider_id])
+
+          results_obs = create_results_obs(encounter, test, params[:date], params[:comments])
+          params[:measures].map { |measure| add_measure_to_results(results_obs, measure, params[:date]) }
+          OrderExtension.create!(creator: User.current, value: result_enter_by, order_id: results_obs.order_id,
+                                 date_created: Time.now)
+
+          serializer = Lab::ResultSerializer.serialize(results_obs)
+        end
+        process_acknowledgement(results_obs, result_enter_by)
+        precess_notification_message(results_obs, serializer, result_enter_by)
+        Rails.logger.info("Lab::ResultsService: Result created for test #{test_id} #{serializer}")
+        serializer
+      end
+
+      private
+
+      def precess_notification_message(result, values, result_enter_by)
+        order = Order.find(result.order_id)
+        data = { Type: result_enter_by,
+                 'Test type': ConceptName.find_by(concept_id: result.test.value_coded)&.name,
+                 'Accession number': order&.accession_number,
+                 'Orde date': Order.columns.include?('start_date') ? order.start_date : order.date_created,
+                 'ARV-Number': find_arv_number(result.person_id),
+                 PatientID: result.person_id,
+                 'Ordered By': Order.columns.include?('provider_id') ? order&.provider&.person&.name : Person.find(order.creator)&.name,
+                 Result: values }.as_json
+        NotificationService.new.create_notification(result_enter_by, data) 
+      end
+
+      def process_acknowledgement(results, results_enter_by)
+        Lab::AcknowledgementService.create_acknowledgement({ order_id: results.order_id, test: results.test.id,
+                                                             date_received: Time.now,
+                                                             entered_by: results_enter_by })
+      end
+
+      def find_arv_number(patient_id)
+        PatientIdentifier.joins(:type)
+                         .merge(PatientIdentifierType.where(name: 'ARV Number'))
+                         .where(patient_id: patient_id)
+                         .first&.identifier
+      end
+
+      def find_encounter(test, encounter_id: nil, encounter_uuid: nil, date: nil, provider_id: nil)
+        return Encounter.find(encounter_id) if encounter_id
+        return Encounter.find_by_uuid(encounter_uuid) if encounter_uuid
+
+        encounter = Encounter.new
+        encounter.patient_id = test.person_id
+        encounter.program_id = test.encounter.program_id if Encounter.column_names.include?('program_id')
+        encounter.visit_id = test.encounter.visit_id if Encounter.column_names.include?('visit_id')
+        encounter.encounter_type = EncounterType.find_by_name!(Lab::Metadata::ENCOUNTER_TYPE_NAME)
+        encounter.encounter_datetime = date || Date.today
+        encounter.provider_id = provider_id || User.current.user_id if Encounter.column_names.include?('provider_id')
+
+        encounter.save!
+
+        encounter
+      end
+
+      # Creates the parent observation for results to which the different measures are attached
+      def create_results_obs(encounter, test, date, comments = nil)
+        void_existing_results_obs(encounter, test)
+        Lab::LabResult.create!(
+          person_id: encounter.patient_id,
+          encounter_id: encounter.encounter_id,
+          concept_id: test_result_concept.concept_id,
+          order_id: test.order_id,
+          obs_group_id: test.obs_id,
+          obs_datetime: date&.to_datetime || DateTime.now,
+          comments: comments
+        )
+      end
+
+      def void_existing_results_obs(encounter, test)
+        result = Lab::LabResult.find_by(person_id: encounter.patient_id,
+                                        concept_id: test_result_concept.concept_id,
+                                        obs_group_id: test.obs_id)
+        return unless result
+
+        OrderExtension.find_by(order_id: result.order_id)&.void("Updated/overwritten by #{User.current.username}")
+        result.measures.map { |child_obs| child_obs.void("Updated/overwritten by #{User.current.username}") }
+        result.void("Updated/overwritten by #{User.current.username}")
+      end
+
+      def test_result_concept
+        ConceptName.find_by_name!(Lab::Metadata::TEST_RESULT_CONCEPT_NAME)
+      end
+
+      def add_measure_to_results(results_obs, params, date)
+        validate_measure_params(params)
+
+        concept_id = params[:indicator][:concept_id] || Concept.find_concept_by_uuid(params.dig(:indicator, :concept))&.id
+
+        Observation.create!(
+          person_id: results_obs.person_id,
+          encounter_id: results_obs.encounter_id,
+          order_id: results_obs.order_id,
+          concept_id: concept_id,
+          obs_group_id: results_obs.obs_id,
+          obs_datetime: date&.to_datetime || DateTime.now,
+          **make_measure_value(params)
+        )
+      end
+
+      def validate_measure_params(params)
+        raise InvalidParameterError, 'measures.value is required' if params[:value].blank?
+
+        if params[:indicator]&.[](:concept_id).blank? && params[:indicator]&.[](:concept).blank?
+          raise InvalidParameterError, 'measures.indicator.concept_id or concept is required'
+        end
+
+        params
+      end
+
+      # Converts user provided measure values to observation_values
+      def make_measure_value(params)
+        obs_value = { value_modifier: params[:value_modifier] }
+        value_type = params[:value_type] || 'text'
+
+        case value_type.downcase
+        when 'numeric' then obs_value.merge(value_numeric: params[:value])
+        when 'boolean' then obs_value.merge(value_boolean: parse_boolen_value(params[:value]))
+        when 'coded' then obs_value.merge(value_coded: params[:value]) # Should we be collecting value_name_coded_id?
+        when 'text' then obs_value.merge(value_text: params[:value])
+        else raise InvalidParameterError, "Invalid value_type: #{params[:value_type]}"
+        end
+      end
+
+      def parse_boolen_value(string)
+        case string.downcase
+        when 'true' then true
+        when 'false' then false
+        else raise InvalidParameterError, "Invalid boolean value: #{string}"
+        end
+      end
+    end
+  end
+end