his_emr_api_lab 1.1.22 → 1.1.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 074eeccc38e08701c9ad01db23814ea8b6add3b17ddc863d67a66c04d0b15488
-  data.tar.gz: 9be44ee134d3ad50ad73ccaf9443c9bd7fe98d46c0a5459e80c62b1f7e3fc6a8
+  metadata.gz: 629116134d63ff0d2d3da97b80b0b9f4a3249483e5d57f43d4f332a645ce35e5
+  data.tar.gz: 414d3a1a4647e666599f71fca7e9026a034f210fbf6080da5cc501bb47c2e24f
 SHA512:
-  metadata.gz: d34ffbf3a18d56a77eec06be6bcd7827a405d505ebb25de2c0c5624259f7e7c29e75fb13e912a47e474b8f261ed8568f47f7c0537e9afdbbfc7bef51563b98f0
-  data.tar.gz: 567f5258355b56afd28da1f418d4524318cf41afef7994515be342e06f8f610369ff51317d1749f36db0d0d4ee2639dbee77482439cc6bc0dfc25467c81e9361
+  metadata.gz: b5bf3f01293464ab6f0be71a8707ab6b57801a371375f1bd6a2fae9812da72d4cba323a5b783e68f9b770db0f6e21c9a39162d89d3004add6b6a8327f7033cf1
+  data.tar.gz: 6c09429e8520fc49459c40737214e1c538079cdacf2b715a9dc856d32bf2b562a8e68a4d5ad9f97bfbe3ead532484f510cc944986475978090755787d118c6f2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Walter Kaunda
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+![Ruby](https://github.com/EGPAFMalawiHIS/HIS-EMR-API-Lab/workflows/Ruby/badge.svg?branch=development)
+# Lab
+
+A Rails engine for [HIS-EMR-API](https://github.com/EGPAFMalawiHIS/HIS-EMR-API)
+compatible applications that provides an API for managing various lab
+activities.
+
+## Usage
+
+The engine provides an API that provides the following functionalities:
+
+  - Search/Retrieve test types
+  - Search/Retrieve sample types for a given test
+  - Order lab tests
+  - Attach a result to a test
+
+For details on how to perform these operations please see the
+[API docs](https://raw.githack.com/EGPAFMalawiHIS/HIS-EMR-API-Lab/development/docs/api.html).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lab', git: 'https://github.com/EGPAFMalawiHIS/HIS-EMR-API-Lab', branch: 'development'
+```
+
+And then execute:
+
+```bash
+$ bundle install lab
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install lab
+```
+
+Finally run:
+
+```bash
+$ bundle exec rails lab:install
+```
+
+## Configuration
+
+This module in most cases should work without any configuration, however to enable
+certain features some configuration may be required. Visit the
+[configuration](./docs/configuration.md) page to learn how to configure the
+application.
+
+## Contributing
+
+Fork this application create a branch for the contribution you want to make,
+push your changes to the branch and then issue a pull request. You may want
+to create a new first on our repository, so that your pull request references
+this issue.
+
+If you are fixing a bug, it will be nice to add a unit test that exposes
+the bug. Although this is not a requirement in most cases.
+
+Be sure to follow [this](https://github.com/rubocop/ruby-style-guide) Ruby
+style guide. We don't necessarily look for strict adherence to the guidelines
+but too much a departure from it is frowned upon. For example, you will be forgiven
+for writing a method with 15 to 20 lines if you clearly justify why you couldn't
+break that method into multiple smaller methods.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Lab'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/controllers/lab/application_controller.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Lab
+  class ApplicationController < ::ApplicationController
+  end
+end

data/app/controllers/lab/labels_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lab
+  class LabelsController < ApplicationController
+    skip_before_action :authenticate
+
+    def print_order_label
+      order_id = params.require(:order_id)
+
+      label = LabellingService::OrderLabel.new(order_id)
+      send_data(label.print, type: 'application/label; charset=utf-8',
+                             stream: false,
+                             filename: "#{SecureRandom.hex(24)}.lbl",
+                             disposition: 'inline')
+    end
+  end
+end

data/app/controllers/lab/orders_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Lab
+  class OrdersController < ApplicationController
+    def create
+      order_params_list = params.require(:orders)
+      orders = order_params_list.map do |order_params|
+        OrdersService.order_test(order_params)
+      end
+
+      orders.each { |order| Lab::PushOrderJob.perform_later(order.fetch(:order_id)) }
+
+      render json: orders, status: :created
+    end
+
+    def update
+      specimen = params.require(:specimen).permit(:concept_id)
+      order = OrdersService.update_order(params[:id], specimen: specimen, force_update: params[:force_update])
+      Lab::PushOrderJob.perform_later(order.fetch(:order_id))
+
+      render json: order
+    end
+
+    def index
+      filters = params.permit(%i[patient_id accession_number date status])
+
+      Lab::UpdatePatientOrdersJob.perform_later(filters[:patient_id]) if filters[:patient_id]
+      render json: OrdersSearchService.find_orders(filters)
+    end
+
+    def destroy
+      OrdersService.void_order(params[:id], params[:reason])
+      Lab::VoidOrderJob.perform_later(params[:id])
+
+      render status: :no_content
+    end
+  end
+end

data/app/controllers/lab/reasons_for_test_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lab
+  class ReasonsForTestController < ApplicationController
+    def index
+      render json: ConceptsService.reasons_for_test
+    end
+  end
+end

data/app/controllers/lab/results_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lab
+  class ResultsController < ApplicationController
+    def create
+      result_params = params.require(:result)
+                            .permit([:encounter_id,
+                                     :date,
+                                     { measures: [:value,
+                                                  :value_type,
+                                                  :value_modifier,
+                                                  { indicator: [:concept_id] }] }])
+
+      result = Lab::ResultsService.create_results(params[:test_id], result_params, 'user entered')
+
+      render json: result, status: :created
+    end
+  end
+end

data/app/controllers/lab/specimen_types_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lab
+  class SpecimenTypesController < ApplicationController
+    def index
+      filters = params.permit(%w[name test_type])
+
+      specimen_types = ConceptsService.specimen_types(name: filters['name'],
+                                                      test_type: filters['test_type'])
+                                      .as_json(only: %w[concept_id name])
+
+      render json: specimen_types
+    end
+  end
+end

data/app/controllers/lab/test_result_indicators_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Lab::TestResultIndicatorsController < ApplicationController
+  def index
+    test_type_id = params.require(:test_type_id)
+
+    render json: Lab::ConceptsService.test_result_indicators(test_type_id)
+  end
+end

data/app/controllers/lab/test_types_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lab
+  class TestTypesController < ApplicationController
+    def index
+      filters = params.permit(%w[name specimen_type])
+
+      test_types = ConceptsService.test_types(name: filters['name'],
+                                              specimen_type: filters['specimen_type'])
+                                  .as_json(only: %w[concept_id name])
+
+      render json: test_types
+    end
+  end
+end

data/app/controllers/lab/tests_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Lab::TestsController < ::ApplicationController
+  def index
+    filters = params.permit(%i[order_date accession_number patient_id test_type_id specimen_type_id pending_results])
+
+    tests = service.find_tests(filters)
+    render json: tests
+  end
+
+  # Add a specimen to an existing order
+  def create
+    test_params = params.permit(:order_id, :date, tests: [:concept_id])
+    order_id, test_concepts = test_params.require(%i[order_id tests])
+    date = test_params[:date] || Date.today
+
+    tests = service.create_tests(Lab::LabOrder.find(order_id), date, test_concepts)
+    Lab::PushOrderJob.perform_later(order_id)
+
+    render json: tests, status: :created
+  end
+
+  def service
+    Lab::TestsService
+  end
+end

data/app/jobs/lab/application_job.rb

@@ -0,0 +1,4 @@
+module Lab
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/lab/push_order_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lab
+  ##
+  # Push an order to LIMS.
+  class PushOrderJob < ApplicationJob
+    def perform(order_id)
+      push_worker = Lab::Lims::PushWorker.new(Lab::Lims::ApiFactory.create_api)
+      push_worker.push_order_by_id(order_id)
+    end
+  end
+end

data/app/jobs/lab/update_patient_orders_job.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Lab
+  ##
+  # Fetches updates on a patient's orders from external sources.
+  class UpdatePatientOrdersJob < ApplicationJob
+    queue_as :default
+
+    def perform(patient_id)
+      Rails.logger.info('Initialising LIMS REST API...')
+
+      User.current = Lab::Lims::Utils.lab_user
+      Location.current = Location.find_by_name('ART clinic')
+
+      lockfile = Rails.root.join('tmp', "update-patient-orders-#{patient_id}.lock")
+
+      done = File.open(lockfile, File::RDWR | File::CREAT) do |lock|
+        unless lock.flock(File::LOCK_NB | File::LOCK_EX)
+          Rails.logger.info('Another update patient job is already running...')
+          break false
+        end
+
+        worker = Lab::Lims::PullWorker.new(Lab::Lims::ApiFactory.create_api)
+        worker.pull_orders(patient_id: patient_id)
+
+        true
+      end
+
+      File.unlink(lockfile) if done
+    end
+  end
+end

data/app/jobs/lab/void_order_job.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lab
+  class VoidOrderJob < ApplicationJob
+    queue_as :default
+
+    def perform(order_id)
+      Rails.logger.info("Voiding order ##{order_id} in LIMS")
+
+      User.current = Lab::Lims::Utils.lab_user
+      Location.current = Location.find_by_name('ART clinic')
+
+      worker = Lab::Lims::PushWorker.new(Lab::Lims::ApiFactory.create_api)
+      worker.push_order(Lab::LabOrder.unscoped.find(order_id))
+    end
+  end
+end

data/app/mailers/lab/application_mailer.rb

@@ -0,0 +1,6 @@
+module Lab
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/lab/application_record.rb

@@ -0,0 +1,5 @@
+module Lab
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/lab/lab_accession_number_counter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lab
+  # Used to keep track of counters for accession numbers.
+  #
+  # An accession number is just a prefix plus a running encounter
+  # that's reset at the end of the day
+  class LabAccessionNumberCounter < ApplicationRecord
+    self.table_name = :lab_accession_number_counters
+
+    validates_presence_of :date, :value
+  end
+end

data/app/models/lab/lab_encounter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lab
+  class LabEncounter < ::Encounter
+    default_scope { joins(:type).merge(EncounterType.where('name LIKE ?', ENCOUNTER_TYPE_NAME)) }
+  end
+end

data/app/models/lab/lab_order.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Lab
+  class LabOrder < ::Order
+    class << self
+      def make_obs_concept_filter(concept_name)
+        concept = ConceptName.where(name: concept_name).select(:concept_id)
+
+        -> { where(concept: concept) }
+      end
+    end
+
+    has_many :tests,
+             make_obs_concept_filter(Lab::Metadata::TEST_TYPE_CONCEPT_NAME),
+             class_name: '::Lab::LabTest',
+             foreign_key: :order_id
+
+    has_many :results,
+             make_obs_concept_filter(Lab::Metadata::TEST_RESULT_CONCEPT_NAME),
+             class_name: 'Observation',
+             foreign_key: :order_id
+
+    has_one :reason_for_test,
+            make_obs_concept_filter(Lab::Metadata::REASON_FOR_TEST_CONCEPT_NAME),
+            class_name: 'Observation',
+            foreign_key: :order_id
+
+    has_one :requesting_clinician,
+            make_obs_concept_filter(Lab::Metadata::REQUESTING_CLINICIAN_CONCEPT_NAME),
+            class_name: 'Observation',
+            foreign_key: :order_id
+
+    has_one :target_lab,
+            make_obs_concept_filter(Lab::Metadata::TARGET_LAB_CONCEPT_NAME),
+            class_name: 'Observation',
+            foreign_key: :order_id
+
+    has_one :mapping,
+            class_name: '::Lab::LimsOrderMapping',
+            foreign_key: :order_id
+
+    default_scope do
+      joins(:order_type)
+        .merge(OrderType.where(name: Lab::Metadata::ORDER_TYPE_NAME))
+        .where.not(concept_id: ConceptName.where(name: 'Tests ordered').select(:concept_id))
+    end
+
+    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)) }
+
+    def self.prefetch_relationships
+      includes(:reason_for_test,
+               :requesting_clinician,
+               :target_lab,
+               tests: [:result])
+    end
+  end
+end

data/app/models/lab/lab_result.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lab
+  class LabResult < Observation
+    alias measures children
+
+    default_scope do
+      lab_test_concept = ConceptName.where(name: Lab::Metadata::TEST_RESULT_CONCEPT_NAME)
+                                    .select(:concept_id)
+      where(voided: 0, concept: lab_test_concept)
+    end
+
+    belongs_to :test,
+               (lambda do
+                  where(concept: ConceptName.where(name: Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
+                                            .select(:concept_id))
+                end),
+               class_name: 'Observation',
+               foreign_key: :obs_group_id
+
+    def void(reason)
+      children.each do |measure|
+        # Need to have a LabResultMeasure model that privately handles it's children
+        measure.children.each { |provider| provider.void(reason) }
+        measure.void(reason)
+      end
+
+      super(reason)
+    end
+  end
+end

data/app/models/lab/lab_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lab
+  class LabTest < ::Observation
+    default_scope do
+      where(concept: ConceptName.where(name: Lab::Metadata::TEST_TYPE_CONCEPT_NAME))
+    end
+
+    has_one :result,
+            -> { where(concept: ConceptName.where(name: Lab::Metadata::TEST_RESULT_CONCEPT_NAME)) },
+            class_name: '::Lab::LabResult',
+            foreign_key: :obs_group_id
+
+    def void(reason)
+      result&.void(reason)
+      super(reason)
+    end
+  end
+end

data/app/models/lab/lims_failed_import.rb

@@ -0,0 +1,4 @@
+module Lab
+  class LimsFailedImport < ApplicationRecord
+  end
+end

data/app/models/lab/lims_order_mapping.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lab
+  class LimsOrderMapping < ApplicationRecord
+    belongs_to :order, class_name: 'LabOrder', foreign_key: 'order_id'
+
+    validates_presence_of :lims_id, :order_id
+    validates_uniqueness_of :lims_id, :order_id
+  end
+end

data/app/serializers/lab/lab_order_serializer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Lab
+  module LabOrderSerializer
+    def self.serialize_order(order, tests: nil, requesting_clinician: nil, reason_for_test: nil, target_lab: nil)
+      tests ||= order.voided == 1 ? voided_tests(order) : order.tests
+      requesting_clinician ||= order.requesting_clinician
+      reason_for_test ||= order.reason_for_test
+      target_lab = target_lab&.value_text || order.target_lab&.value_text || Location.current_health_center&.name
+
+      ActiveSupport::HashWithIndifferentAccess.new(
+        {
+          id: order.order_id,
+          order_id: order.order_id, # Deprecated: Link to :id
+          encounter_id: order.encounter_id,
+          order_date: order.start_date,
+          patient_id: order.patient_id,
+          accession_number: order.accession_number,
+          specimen: {
+            concept_id: order.concept_id,
+            name: concept_name(order.concept_id)
+          },
+          requesting_clinician: requesting_clinician&.value_text,
+          target_lab: target_lab,
+          reason_for_test: {
+            concept_id: reason_for_test&.value_coded,
+            name: concept_name(reason_for_test&.value_coded)
+          },
+          tests: tests.map do |test|
+            result_obs = test.children.first
+
+            {
+              id: test.obs_id,
+              concept_id: test.value_coded,
+              name: concept_name(test.value_coded),
+              result: result_obs && ResultSerializer.serialize(result_obs)
+            }
+          end
+        }
+      )
+    end
+
+    def self.concept_name(concept_id)
+      return concept_id unless concept_id
+
+      ConceptName.select(:name).find_by_concept_id(concept_id)&.name
+    end
+
+    def self.voided_tests(order)
+      concept = ConceptName.where(name: Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
+                           .select(:concept_id)
+      LabTest.unscoped.where(concept: concept, order: order, voided: true)
+    end
+  end
+end

data/app/serializers/lab/result_serializer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Lab
+  ##
+  # Serialize a Lab order result
+  module ResultSerializer
+    def self.serialize(result)
+      result.children.map do |measure|
+        value, value_type = read_value(measure)
+        concept_name = ConceptName.find_by_concept_id(measure.concept_id)
+
+        {
+          id: measure.obs_id,
+          indicator: {
+            concept_id: concept_name&.concept_id,
+            name: concept_name&.name
+          },
+          date: measure.obs_datetime,
+          value: value,
+          value_type: value_type,
+          value_modifier: measure.value_modifier
+        }
+      end
+    end
+
+    def self.read_value(measure)
+      %w[value_numeric value_coded value_boolean value_text].each do |field|
+        value = measure.send(field)
+
+        return [value, field.split('_')[1]] if value
+      end
+
+      [nil, 'unknown']
+    end
+  end
+end

data/app/serializers/lab/test_serializer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lab
+  module TestSerializer
+    def self.serialize(test, order: nil, result: nil)
+      order ||= test.order
+      result ||= test.result
+
+      {
+        id: test.obs_id,
+        concept_id: test.value_coded,
+        name: ConceptName.find_by_concept_id(test.value_coded)&.name,
+        order: {
+          id: order.order_id,
+          concept_id: order.concept_id,
+          name: ConceptName.find_by_concept_id(order.concept_id)&.name,
+          accession_number: order.accession_number
+        },
+        result: if result
+                  {
+                    id: result.obs_id,
+                    modifier: result.value_modifier,
+                    value: result.value_text
+                  }
+                end
+      }
+    end
+  end
+end