mahis_emr_api_lab 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ce5389cf6e11fd5a6b5f220f8a5fec9ae5b08c9b2cfa26bddf0df79bbc34e739
+  data.tar.gz: 0e6cea217c13781dc92aeef61f03afef67cd9e21ab79909ed942a2dd7052f23b
+SHA512:
+  metadata.gz: 609b8532761b2cc4f144a6a1644de3275be4bf8c9134f8dbf96e2716d108eddf95f56a7f5b0c1c26b3b6554b5903c421b75e487de6b3f0b6cf23e57e8754360f
+  data.tar.gz: acc79fb836b4035659d48ae14b848454d36e6a1682fc15a68b9c8cde73021ac42759f31f11e64e17439d8b881bea9c7dbac889105b339898c81765e015f85d79

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,78 @@
+# frozen_string_literal: true
+
+module Lab
+  class OrdersController < ApplicationController
+    skip_before_action :authorize_request, only: %i[order_status order_result]
+
+    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 patient accession_number date status])
+
+      id = filters[:patient_id] || filters[:patient]
+
+      patient = Patient.find(id) if filters[:patient_id] || filters[:patient]
+
+      Lab::UpdatePatientOrdersJob.perform_later(patient.id) if filters[:patient_id] || filters[:patient]
+      orders = OrdersSearchService.find_orders(filters)
+      begin
+        render json: orders.reload, status: :ok
+      rescue StandardError
+        render json: orders
+      end
+    end
+
+    def verify_tracking_number
+      tracking_number = params.require(:accession_number)
+      render json: { exists: OrdersService.check_tracking_number(tracking_number) }, status: :ok
+    end
+
+    def destroy
+      OrdersService.void_order(params[:id], params[:reason])
+      Lab::VoidOrderJob.perform_later(params[:id])
+
+      render status: :no_content
+    end
+
+    def order_status
+      order_params = params.permit(:tracking_number, :status, :status_time, :comments)
+      OrdersService.update_order_status(order_params)
+      render json: { message: "Status for order #{order_params['tracking_number']} successfully updated" }, status: :ok
+    end
+
+    def order_result
+      params.permit!
+      order_params = params[:data].to_h
+      OrdersService.update_order_result(order_params)
+      render json: { message: 'Results processed successfully' }, status: :ok
+    end
+
+    private
+
+    def authenticate_request
+      decoded_user = authorize_request
+      user(decoded_user)
+    end
+
+    def user(decoded)
+      User.current = User.find decoded[:user_id]
+    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,20 @@
+# frozen_string_literal: true
+
+module Lab
+  class ResultsController < ApplicationController
+    def create
+      result_params = params.require(:result)
+                            .permit([:encounter_id,
+                                     :encounter,
+                                     :date,
+                                     { measures: [:value,
+                                                  :value_type,
+                                                  :value_modifier,
+                                                  { indicator: %i[concept_id concept] }] }])
+
+      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,25 @@
+# frozen_string_literal: true
+
+class Lab::TestsController < ::ApplicationController
+  def index
+    filters = params.permit(%i[order_date accession_number patient 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/controllers/lab/users_controller.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# This controller handles creation and authentication of LIMS User
+module Lab
+  class UsersController < ::ApplicationController
+    skip_before_action :authenticate
+    # create a LIMS User that will be responsible for sending lab results
+    def create
+      user_params = params.permit(:username, :password)
+      service.create_lims_user(username: user_params['username'], password: user_params['password'])
+      render json: { message: 'User successfully created' }, status: 200
+    end
+
+    # authenticate the lims user
+    def login
+      user_params = params.permit(:username, :password)
+      result = service.authenticate_user(username: user_params['username'], password: user_params['password'],
+                                         user_agent: request.user_agent, request_ip: request.remote_ip)
+      if result.present?
+        render json: result, status: 200
+      else
+        render json: { message: 'Invalid Credentials Provided' }, status: 401
+      end
+    end
+
+    private
+
+    def service
+      Lab::UserService
+    end
+  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_acknowledgement.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Lab
+  class LabAcknowledgement < ::LimsAcknowledgementStatus
+  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/models/lab/order_extension.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# model managing extra details for orders
+class Lab::OrderExtension < ApplicationRecord
+  include Voidable
+  self.table_name = :order_extension
+  self.primary_key = :order_extension_id
+
+  default_scope { where(voided: 0) }
+  scope :voided, -> { unscoped.where.not(voided: 0) }
+
+  belongs_to :order, foreign_key: :order_id
+  belongs_to :creator, class_name: 'User', foreign_key: :creator
+end