mahis_his_emr_api_lab 1.2.0

data/app/services/lab/tests_service.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Lab
+  ##
+  # Manage tests that have been ordered through the ordering service.
+  module TestsService
+    class << self
+      def find_tests(filters)
+        tests = Lab::LabTest.all
+        patient_id = filters.delete(:patient_id)
+        patient_id ||= ::Patient.find(filters.delete(:patient))&.id if filters[:patient]
+
+        Lab::UpdatePatientOrdersJob.perform_later(patient_id) if patient_id
+
+        tests = filter_tests(tests, test_type_id: filters.delete(:test_type_id),
+                                    patient_id: filters.delete(:patient_id),
+                                    patient: filters.delete(:patient)
+                                    )
+
+        tests = filter_tests_by_results(tests) if %w[1 true].include?(filters[:pending_results]&.downcase)
+
+        tests = filter_tests_by_order(tests, accession_number: filters.delete(:accession_number),
+                                             order_date: filters.delete(:order_date),
+                                             specimen_type_id: filters.delete(:specimen_type_id))
+
+        tests.map { |test| Lab::TestSerializer.serialize(test) }
+      end
+
+      def create_tests(order, date, tests_params)
+        raise InvalidParameterError, 'tests are required' if tests_params.nil? || tests_params.empty?
+
+        
+        Lab::LabTest.transaction do
+          tests_params.map do |params|
+            concept_id = params[:concept_id]
+            concept_id = Concept.find_concept_by_uuid(params[:concept]).id if concept_id.nil?
+            
+            test = Lab::LabTest.create!(
+              concept_id: ConceptName.find_by_name!(Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
+                                     .concept_id,
+              encounter_id: order.encounter_id,
+              order_id: order.order_id,
+              person_id: order.patient_id,
+              obs_datetime: date&.to_time || Time.now,
+              value_coded: concept_id
+            )
+
+            Lab::TestSerializer.serialize(test, order: order)
+          end
+        end
+      end
+
+      private
+
+      ##
+      # Filter a LabTests Relation.
+      def filter_tests(tests, test_type_id: nil, patient_id: nil, patient: nil)
+        tests = tests.where(value_coded: test_type_id) if test_type_id
+        tests = tests.where(person_id: patient_id) if patient_id
+        person = ::Person.find_by_uuid(patient) if patient
+        tests = tests.where(person_id: person&.patient&.id) if patient
+
+        tests
+      end
+
+      ##
+      # Filter out any tests having results
+      def filter_tests_by_results(tests)
+        tests.where.not(obs_id: Lab::LabResult.all.select(:obs_group_id))
+      end
+
+      ##
+      # Filter LabTests Relation using their parent orders parameters.
+      def filter_tests_by_order(tests, accession_number: nil, order_date: nil, specimen_type_id: nil)
+        return tests unless accession_number || order_date || specimen_type_id
+
+        lab_orders = filter_orders(Lab::LabOrder.all, accession_number: accession_number,
+                                                      order_date: order_date,
+                                                      specimen_type_id: specimen_type_id)
+        tests.joins(:order).merge(lab_orders)
+      end
+
+      def filter_orders(orders, accession_number: nil, order_date: nil, specimen_type_id: nil)
+        if order_date
+          order_date = order_date.to_date
+          orders = orders.where('start_date >= ? AND start_date < ?', order_date, order_date + 1.day)
+        end
+
+        orders = orders.where(accession_number: accession_number) if accession_number
+        orders = orders.where(concept_id: specimen_type_id) if specimen_type_id
+
+        orders
+      end
+
+      def create_test(order, date, test_type_id)
+        create_order_observation(
+          order,
+          Lab::Metadata::TEST_TYPE_CONCEPT_NAME,
+          date,
+          value_coded: test_type_id
+        )
+      end
+    end
+  end
+end

data/app/services/lab/user_service.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lab
+  # Service for managing LIMS users
+  module UserService
+    class << self
+      include BCrypt
+
+      def create_lims_user(username:, password:)
+        validate username: username
+        ActiveRecord::Base.transaction do
+          person = create_lims_person
+          create_user username: username, password: password, person: person
+        end
+      end
+
+      def authenticate_user(username:, password:, user_agent:, request_ip:)
+        user = User.find_by_username username
+        encrypted_pass = Password.new(user.password)
+        if encrypted_pass == password
+          generate_token(user, user_agent, request_ip)
+        else
+          # throw authentication error
+          nil
+        end
+      end
+
+      private
+
+      ##
+      # Validate that the username doesn't already exists
+      def validate(username:)
+        raise UnprocessableEntityError, 'Username already exists' if User.find_by_username username
+      end
+
+      def create_lims_person
+        god_user = User.first
+        person = Person.create!(creator: god_user.id)
+        PersonName.create!(given_name: 'Lims', family_name: 'User', creator: god_user.id, person: person)
+        person
+      end
+
+      def create_user(username:, password:, person:)
+        salt = SecureRandom.base64
+        user = User.create!(
+          username: username,
+          password: Password.create(password),
+          salt: salt,
+          person: person,
+          creator: User.first.id
+        )
+      end
+
+      def generate_token(user, user_agent, request_ip)
+        browser = Browser.new(user_agent)
+        key_supplement = request_ip + browser.name + browser.version
+        token = Lab::JsonWebTokenService.encode({ user_id: user.id }, key_supplement)
+        { auth_token: token }
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+Lab::Engine.routes.draw do
+  resources :orders, path: 'api/v1/lab/orders' do
+    collection do
+      post :order_status
+      post :order_result
+    end
+  end
+  resources :tests, path: 'api/v1/lab/tests', except: %i[update] do # ?pending=true to select tests without results?
+    resources :results, only: %i[index create destroy]
+  end
+
+  get 'api/v1/lab/labels/order', to: 'labels#print_order_label'
+  get 'api/v1/lab/accession_number', to: 'orders#verify_tracking_number'
+
+  # Metadata
+  # TODO: Move the following to namespace /concepts
+  resources :specimen_types, only: %i[index], path: 'api/v1/lab/specimen_types'
+  resources :test_result_indicators, only: %i[index], path: 'api/v1/lab/test_result_indicators'
+  resources :test_types, only: %i[index], path: 'api/v1/lab/test_types'
+  resources :reasons_for_test, only: %i[index], path: 'api/v1/lab/reasons_for_test'
+  resources :users, only: %i[create], path: 'api/v1/lab/users' do
+    collection do
+      post :login
+    end
+  end
+end

data/db/migrate/20210126092910_create_lab_lab_accession_number_counters.rb

@@ -0,0 +1,12 @@
+class CreateLabLabAccessionNumberCounters < ActiveRecord::Migration[5.2]
+  def change
+    create_table :lab_accession_number_counters do |t|
+      t.date :date
+      t.bigint :value
+
+      t.timestamps
+
+      t.index %i[date], unique: true
+    end
+  end
+end

data/db/migrate/20210310115457_create_lab_lims_order_mappings.rb

@@ -0,0 +1,15 @@
+class CreateLabLimsOrderMappings < ActiveRecord::Migration[5.2]
+  def change
+    create_table :lab_lims_order_mappings do |t|
+      t.integer :lims_id, null: false, unique: true
+      t.integer :order_id, null: false, unique: true
+      t.datetime :pushed_at
+      t.datetime :pulled_at
+
+      t.timestamps
+
+      t.foreign_key :orders, primary_key: :order_id, column: :order_id
+      t.index :lims_id
+    end
+  end
+end

data/db/migrate/20210323080140_change_lims_id_to_string_in_lims_order_mapping.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ChangeLimsIdToStringInLimsOrderMapping < ActiveRecord::Migration[5.2]
+  def change
+    reversible do |direction|
+      direction.up do
+        change_column :lab_lims_order_mappings, :lims_id, :string, null: false
+      end
+
+      direction.down do
+        change_column :lab_lims_order_mappings, :lims_id, :integer, null: false
+      end
+    end
+  end
+end

data/db/migrate/20210326195504_add_order_revision_to_lims_order_mapping.rb

@@ -0,0 +1,5 @@
+class AddOrderRevisionToLimsOrderMapping < ActiveRecord::Migration[5.2]
+  def change
+    add_column :lab_lims_order_mappings, :revision, :string
+  end
+end

data/db/migrate/20210407071728_create_lab_lims_failed_imports.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateLabLimsFailedImports < ActiveRecord::Migration[5.2]
+  def change
+    create_table :lab_lims_failed_imports do |t|
+      t.string :lims_id, null: false
+      t.string :tracking_number, null: false
+      t.string :patient_nhid, null: false
+      t.string :reason, null: false
+      t.string :diff, limit: 2048
+
+      t.timestamps
+
+      t.index :lims_id
+      t.index :patient_nhid
+      t.index :tracking_number
+    end
+  end
+end

data/db/migrate/20210610095024_fix_numeric_results_value_type.rb

@@ -0,0 +1,20 @@
+class FixNumericResultsValueType < ActiveRecord::Migration[5.2]
+  def up
+    results = Lab::LabResult.all.includes(:children)
+
+    ActiveRecord::Base.connection.transaction do
+      results.each do |result|
+        result.children.each do |measure|
+          next unless measure.value_text&.match?(/^[+-]?((\d+(\.\d+)?)|\.\d+)$/)
+
+          puts "Updating result value type for result measure ##{measure.obs_id}"
+          measure.value_numeric = measure.value_text
+          measure.value_text = nil
+          measure.save!
+        end
+      end
+    end
+  end
+
+  def down; end
+end

data/db/migrate/20210807111531_add_default_to_lims_order_mapping.rb

@@ -0,0 +1,7 @@
+class AddDefaultToLimsOrderMapping < ActiveRecord::Migration[5.2]
+  def up
+    change_column :lab_lims_order_mappings, :revision, :string, limit: 256, default: nil, null: true
+  end
+
+  def down; end
+end

data/lib/auto12epl.rb

@@ -0,0 +1,201 @@
+#!/usr/bin/ruby
+# Jeremy Espino MD MS
+# 28-JAN-2016
+
+
+class Float
+  # function to round down a float to an integer value
+  def round_down n=0
+    n < 1 ? self.to_i.to_f : (self - 0.5 / 10**n).round(n)
+  end
+end
+
+# Generates EPL code that conforms to the Auto12-A standard for specimen labeling
+class Auto12Epl
+
+  attr_accessor :element_font
+  attr_accessor :barcode_human_font
+
+  DPI = 203
+  LABEL_WIDTH_IN = 2.0
+  LABEL_HEIGHT_IN = 0.5
+
+  # font constants
+  FONT_X_DOTS = [8, 10, 12, 14, 32]
+  FONT_Y_DOTS = [12, 16, 20, 24, 24]
+  FONT_PAD_DOTS = 2
+
+  # element heights
+  HEIGHT_MARGIN = 0.031
+  HEIGHT_ELEMENT = 0.1
+  HEIGHT_ELEMENT_SPACE = 0.01
+  HEIGHT_PID = 0.1
+  HEIGHT_BARCODE = 0.200
+  HEIGHT_BARCODE_HUMAN = 0.050
+
+  # element widths
+  WIDTH_ELEMENT = 1.94
+  WIDTH_BARCODE = 1.395
+  WIDTH_BARCODE_HUMAN = 1.688
+
+  # margins
+  L_MARGIN = 0.031
+  L_MARGIN_BARCODE = 0.25
+
+  # stat locations
+  L_MARGIN_BARCODE_W_STAT = 0.200
+  L_MARGIN_W_STAT = 0.150
+  STAT_WIDTH_ELEMENT = 1.78
+  STAT_WIDTH_BARCODE = 1.150
+  STAT_WIDTH_BARCODE_HUMAN = 1.400
+
+  # constants for generated EPL code
+  BARCODE_TYPE = '1A'
+  BARCODE_NARROW_WIDTH = '2'
+  BARCODE_WIDE_WIDTH = '2'
+  BARCODE_ROTATION = '0'
+  BARCODE_IS_HUMAN_READABLE = 'N'
+  ASCII_HORZ_MULT = 1
+  ASCII_VERT_MULT = 1
+
+
+  def initialize(element_font = 1, barcode_human_font = 1)
+    @element_font = element_font
+    @barcode_human_font = barcode_human_font
+  end
+
+  # Calculate the number of characters that will fit in a given length
+  def max_characters(font, length)
+
+    dots_per_char = FONT_X_DOTS.at(font-1) + FONT_PAD_DOTS
+
+    num_char = ( (length * DPI)  / dots_per_char).round_down
+
+    num_char.to_int
+  end
+
+  # Use basic truncation rule to truncate the name element i.e., if > maxCharacters cutoff and trail with +
+  def truncate_name(last_name, first_name, middle_initial, is_stat)
+    if is_stat
+      name_max_characters = max_characters(@element_font, STAT_WIDTH_ELEMENT)
+    else
+      name_max_characters = max_characters(@element_font, WIDTH_ELEMENT)
+    end
+
+    if concatName(last_name, first_name, middle_initial).length > name_max_characters
+      # truncate last?
+      if last_name.length > 12
+        last_name = last_name[0..11] + '+'
+      end
+
+      # truncate first?
+      if concatName(last_name, first_name, middle_initial).length  > name_max_characters && first_name.length > 7
+        first_name = first_name[0..7] + '+'
+      end
+    end
+
+    concatName(last_name, first_name, middle_initial)
+
+  end
+
+  def concatName(last_name, first_name, middle_initial)
+    last_name + ', ' + first_name + (middle_initial == nil ? '' : ' ' + middle_initial)
+  end
+
+  # The main function to generate the EPL
+  def generate_epl(last_name, first_name, middle_initial, pid, dob, age, gender, col_date_time, col_name, tests, stat, acc_num, schema_track)
+
+    # format text and set margin
+    if stat == nil
+      name_text = truncate_name(last_name, first_name, middle_initial, false)
+      pid_dob_age_gender_text = full_justify(pid, dob + ' ' + age + ' ' + gender, @element_font, WIDTH_ELEMENT)
+      l_margin = L_MARGIN
+      l_margin_barcode = L_MARGIN_BARCODE
+    else
+      name_text = truncate_name(last_name, first_name, middle_initial, true)
+      pid_dob_age_gender_text = full_justify(pid, dob + ' ' + age + ' ' + gender, @element_font, STAT_WIDTH_ELEMENT)
+      stat_element_text = pad_stat_w_space(stat)
+      l_margin = L_MARGIN_W_STAT
+      l_margin_barcode = L_MARGIN_BARCODE_W_STAT
+    end
+    barcode_human_text = "#{acc_num} * #{schema_track.gsub(/\-/i, '')}"
+    collector_element_text = "Col: #{col_date_time} #{col_name}"
+    tests_element_text = tests
+
+    # generate EPL statements
+    name_element = generate_ascii_element(to_dots(l_margin), to_dots(HEIGHT_MARGIN), 0, @element_font, false, name_text)
+    pid_dob_age_gender_element = generate_ascii_element(to_dots(l_margin), to_dots(HEIGHT_MARGIN + HEIGHT_ELEMENT + HEIGHT_ELEMENT_SPACE), 0, @element_font, false, pid_dob_age_gender_text)
+    barcode_human_element = generate_ascii_element(to_dots(l_margin_barcode), to_dots(HEIGHT_MARGIN + HEIGHT_ELEMENT + HEIGHT_ELEMENT_SPACE + HEIGHT_ELEMENT + HEIGHT_ELEMENT_SPACE + HEIGHT_BARCODE), 0, @barcode_human_font, false, barcode_human_text)
+    collector_element = generate_ascii_element(to_dots(l_margin), to_dots(HEIGHT_MARGIN + HEIGHT_ELEMENT + HEIGHT_ELEMENT_SPACE + HEIGHT_ELEMENT + HEIGHT_ELEMENT_SPACE + HEIGHT_BARCODE + HEIGHT_BARCODE_HUMAN + HEIGHT_ELEMENT_SPACE), 0, @element_font, false, collector_element_text)
+    tests_element = generate_ascii_element(to_dots(l_margin), to_dots(HEIGHT_MARGIN + HEIGHT_ELEMENT + HEIGHT_ELEMENT_SPACE + HEIGHT_ELEMENT + HEIGHT_ELEMENT_SPACE + HEIGHT_BARCODE + HEIGHT_BARCODE_HUMAN + HEIGHT_ELEMENT_SPACE + HEIGHT_ELEMENT + HEIGHT_ELEMENT_SPACE), 0, @element_font, false, tests_element_text)
+    barcode_element = generate_barcode_element(to_dots(l_margin_barcode), to_dots(HEIGHT_MARGIN + HEIGHT_ELEMENT + HEIGHT_ELEMENT_SPACE + HEIGHT_ELEMENT + HEIGHT_ELEMENT_SPACE), to_dots(HEIGHT_BARCODE)-4, schema_track)
+    stat_element = generate_ascii_element(to_dots(L_MARGIN)+FONT_Y_DOTS.at(@element_font - 1)+FONT_PAD_DOTS, to_dots(HEIGHT_MARGIN), 1, @element_font, true, stat_element_text)
+
+    # combine EPL statements
+    if stat == nil
+      "\nN\nR216,0\nZT\nS1\n#{name_element}\n#{pid_dob_age_gender_element}\n#{barcode_element}\n#{barcode_human_element}\n#{collector_element}\n#{tests_element}\nP3\n"
+    else
+      "\nN\nR216,0\nZT\nS1\n#{name_element}\n#{pid_dob_age_gender_element}\n#{barcode_element}\n#{barcode_human_element}\n#{collector_element}\n#{tests_element}\n#{stat_element}\nP3\n"
+    end
+
+  end
+
+  # Add spaces before and after the stat text so that black bars appear across the left edge of label
+  def pad_stat_w_space(stat)
+    num_char = max_characters(@element_font, LABEL_HEIGHT_IN)
+    spaces_needed = (num_char - stat.length) / 1
+    space = ''
+    spaces_needed.times do
+      space = space + ' '
+    end
+    space + stat + space
+  end
+
+  # Add spaces between the NPID and the dob/age/gender so that line is fully justified
+  def full_justify(pid, dag, font, length)
+    max_char = max_characters(font, length)
+    spaces_needed = max_char - pid.length - dag.length
+    space = ''
+    spaces_needed.times do
+      space = space + ' '
+    end
+    pid + space + dag
+  end
+
+  # convert inches to number of dots using DPI
+  def to_dots(inches)
+    (inches * DPI).round
+  end
+
+  # generate ascii EPL
+  def generate_ascii_element(x, y, rotation, font, is_reverse, text)
+    "A#{x.to_s},#{y.to_s},#{rotation.to_s},#{font.to_s},#{ASCII_HORZ_MULT},#{ASCII_VERT_MULT},#{is_reverse ? 'R' : 'N'},\"#{text}\""
+  end
+
+  # generate barcode EPL
+  def generate_barcode_element(x, y, height, schema_track)
+    schema_track = schema_track.gsub("-", "").strip
+    "B#{x.to_s},#{y.to_s},#{BARCODE_ROTATION},#{BARCODE_TYPE},#{BARCODE_NARROW_WIDTH},#{BARCODE_WIDE_WIDTH},#{height.to_s},#{BARCODE_IS_HUMAN_READABLE},\"#{schema_track}\""
+  end
+
+end
+
+if __FILE__ == $0
+
+  auto = Auto12Epl.new
+
+  puts auto.generate_epl("Banda", "Mary", "U", "Q23-HGF", "12-SEP-1997", "19y", "F", "01-JAN-2016 14:21", "byGD", "CHEM7,Ca,Mg", nil, "KCH-16-00001234", "1600001234")
+  puts "\n"
+  puts auto.generate_epl("Banda", "Mary", "U", "Q23-HGF", "12-SEP-1997", "19y", "F", "01-JAN-2016 14:21", "byGD", "CHEM7,Ca,Mg", "STAT CHEM", "KCH-16-00001234", "1600001234")
+  puts "\n"
+  puts auto.generate_epl("Bandajustrightlas", "Mary", "U", "Q23-HGF", "12-SEP-1997", "19y", "F", "01-JAN-2016 14:21", "byGD", "CHEM7,Ca,Mg", "STAT CHEM", "KCH-16-00001234", "1600001234")
+  puts "\n"
+  puts auto.generate_epl("Bandasuperlonglastnamethatwonfit", "Marysuperlonglastnamethatwonfit", "U", "Q23-HGF", "12-SEP-1997", "19y", "F", "01-JAN-2016 14:21", "byGD", "CHEM7,Ca,Mg", "STAT CHEM", "KCH-16-00001234", "1600001234")
+  puts "\n"
+  puts auto.generate_epl("Bandasuperlonglastnamethatwonfit", "Mary", "U", "Q23-HGF", "12-SEP-1997", "19y", "F", "01-JAN-2016 14:21", "byGD", "CHEM7,Ca,Mg", "STAT CHEM", "KCH-16-00001234", "1600001234")
+  puts "\n"
+  puts auto.generate_epl("Banda", "Marysuperlonglastnamethatwonfit", "U", "Q23-HGF", "12-SEP-1997", "19y", "F", "01-JAN-2016 14:21", "byGD", "CHEM7,Ca,Mg", "STAT CHEM", "KCH-16-00001234", "1600001234")
+
+
+
+end

data/lib/couch_bum/couch_bum.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'couchrest'
+
+##
+# A CouchRest wrapper for the changes API.
+#
+# See: https://github.com/couchrest/couchrest
+class CouchBum
+  cattr_accessor :logger
+
+  def initialize(database:, protocol: 'http', host: 'localhost', port: 5984, username: nil, password: nil)
+    @connection_string = make_connection_string(protocol, username, password, host, port, database)
+
+    CouchBum.logger ||= Logger.new(STDOUT)
+  end
+
+  ##
+  # Attaches to the Changes API and streams the updates to passed block.
+  #
+  # This is a blocking call that only stops when there are no more
+  # changes to pull or is explicitly terminated by calling +choke+
+  # within the passed block.
+  def binge_changes(since: 0, limit: nil, include_docs: nil, &block)
+    catch(:choke) do
+      logger.debug("Binging #{limit} changes from '#{since}'")
+      params = stringify_params(limit: limit, include_docs: include_docs)
+      params = "since=#{since}&#{params}" unless since.blank?
+
+      changes = couch_rest(:get, "_changes?#{params}")
+      context = BingeContext.new(changes)
+      changes['results'].each do |change|
+        context.current_seq = change['seq']
+        context.instance_exec(change, &block)
+      end
+    end
+  end
+
+  def couch_rest(method, route, *args, **kwargs)
+    url = expand_route(route)
+    CouchRest.send(method, url, *args, **kwargs)
+  rescue CouchRest::Exception => e
+    logger.error("Failed to communicate with CouchDB: Status: #{e.http_code} - #{e.http_body}")
+    raise e
+  end
+
+  private
+
+  # Context under which the callback passed to binge_changes is executed.
+  class BingeContext
+    attr_accessor :current_seq
+
+    def initialize(changes)
+      @changes = changes
+    end
+
+    def choke
+      throw :choke
+    end
+
+    def last_seq
+      @changes['last_seq']
+    end
+
+    def pending
+      @changes['pending']
+    end
+  end
+
+  def make_connection_string(protocol, username, password, host, port, database)
+    auth = username ? "#{CGI.escape(username)}:#{CGI.escape(password)}@" : ''
+
+    "#{protocol}://#{auth}#{host}:#{port}/#{database}"
+  end
+
+  def expand_route(route)
+    route = route.gsub(%r{^/+}, '')
+
+    "#{@connection_string}/#{route}"
+  end
+
+  def stringify_params(params)
+    params.reduce('') do |str_params, entry|
+      name, value = entry
+      next params unless value
+
+      param = "#{name}=#{value}"
+      str_params.empty? ? param : "#{str_params}&#{param}"
+    end
+  end
+end

data/lib/generators/lab/install/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Installs the Lab engine.
+
+Example:
+    rails generate lab:install
+
+    This will create:
+        config/initializers/rswag-ui-lab.rb
+        swagger/lab/v1/swagger.yaml

data/lib/generators/lab/install/install_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lab
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('templates', __dir__)
+
+    def copy_openapi_docs
+      copy_file('swagger.yaml', 'swagger/lab/v1/swagger.yaml')
+    end
+
+    def copy_rswag_initializer
+      copy_file('rswag-ui-lab.rb', 'config/initializers/rswag-ui-lab.rb')
+    end
+
+    def copy_worker
+      copy_file('start_worker.rb', 'bin/lab/start_worker.rb')
+    end
+  end
+end

data/lib/generators/lab/install/templates/rswag-ui-lab.rb

@@ -0,0 +1,5 @@
+require 'rswag/ui'
+
+Rswag::Ui.configure do |c|
+  c.swagger_endpoint '/api-docs/lab/v1/swagger.yaml', 'Lab API V1 Docs'
+end

data/lib/generators/lab/install/templates/start_worker.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'logger_multiplexor'
+
+Rails.logger = LoggerMultiplexor.new(Rails.root.join('log/lims-push.log'), $stdout)
+api = Lab::Lims::Api.new
+worker = Lab::Lims::Worker.new(api)
+
+def with_lock(lock_file)
+  File.open("log/#{lock_file}", File::RDWR | File::CREAT, 0o644) do |file|
+    unless file.flock(File::LOCK_EX | File::LOCK_NB)
+      Rails.logger.warn("Failed to start new process due to lock: #{lock_file}")
+      exit 2
+    end
+
+    file.rewind
+    file.puts("Process ##{Process.pid} started at #{Time.now}")
+
+    yield
+  end
+end
+
+case ARGV[0]&.downcase
+when 'push'
+  with_lock('lims-push.lock') { worker.push_orders }
+when 'pull'
+  with_lock('lims-pull.lock') { worker.pull_orders }
+else
+  warn 'Error: No or invalid action specified: Valid actions are push and pull'
+  warn 'USAGE: rails runner start_worker.rb push'
+  exit 1
+end