his_emr_api_lab 2.1.9.pre.beta → 2.2.1

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

@@ -5,15 +5,16 @@ module Lab
     ##
     # Pushes all local orders to a LIMS Api object.
     class PushWorker
-      attr_reader :lims_api
+      attr_reader :lims_api, :start_date
 
       include Utils # for logger
 
       SECONDS_TO_WAIT_FOR_ORDERS = 30
       START_DATE = Time.parse('2024-09-03').freeze
 
-      def initialize(lims_api)
+      def initialize(lims_api, start_date: nil)
         @lims_api = lims_api
+        @start_date = start_date
       end
 
       def push_orders(batch_size: 1000, wait: false)
@@ -81,8 +82,8 @@ module Lab
 
       def void_order_in_lims(order_id)
         order = Lab::LabOrder.joins(order_type: { name: 'Lab' })
-        .unscoped
-        .find(order_id)
+                             .unscoped
+                             .find(order_id)
         order_dto = Lab::Lims::OrderSerializer.serialize_order(order)
         Rails.logger.info("Deleting order ##{order_dto[:accession_number]} from LIMS")
         lims_api.delete_order('', order_dto)
@@ -100,10 +101,16 @@ module Lab
 
       def new_orders
         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)
+        query = Lab::LabOrder.where.not(order_id: Lab::LimsOrderMapping.all.select(:order_id))
+                             .where("accession_number IS NOT NULL AND accession_number !=''")
+
+        query = if start_date
+                  query.where('orders.date_created >= ?', start_date)
+                else
+                  query.where('orders.date_created >= ? AND orders.date_created <= ?', START_DATE, Date.today + 1.day)
+                end
+
+        query.order(date_created: :desc)
       end
 
       def updated_orders

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

@@ -43,8 +43,7 @@ module Lab
       end
 
       def self.lab_user
-        # Use unscoped to find user regardless of location context
-        user = User.unscoped.find_by_username('lab_daemon')
+        user = User.find_by_username('lab_daemon')
         return user if user
 
         god_user = User.first

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

@@ -9,43 +9,43 @@ module Lab
     ##
     # Pull/Push orders from/to the LIMS queue (Oops meant CouchDB).
     module Worker
-      def self.start
+      def self.start(start_date: nil)
         User.current = Utils.lab_user
 
-        fork(&method(:start_push_worker))
-        fork(&method(:start_pull_worker))
-        fork(&method(:start_acknowledgement_worker))
-        fork(&method(:start_realtime_pull_worker)) if realtime_updates_enabled?
+        fork { start_push_worker(start_date: start_date) }
+        fork { start_pull_worker(start_date: start_date) }
+        fork { start_acknowledgement_worker(start_date: start_date) }
+        fork { start_realtime_pull_worker(start_date: start_date) } if realtime_updates_enabled?
 
         Process.waitall
       end
 
-      def self.start_push_worker
+      def self.start_push_worker(start_date: nil)
         start_worker('push_worker') do
-          worker = PushWorker.new(lims_api)
+          worker = PushWorker.new(lims_api, start_date: start_date)
 
           worker.push_orders # (wait: true)
         end
       end
 
-      def self.start_acknowledgement_worker
+      def self.start_acknowledgement_worker(start_date: nil)
         start_worker('acknowledgement_worker') do
-          worker = AcknowledgementWorker.new(lims_api)
+          worker = AcknowledgementWorker.new(lims_api, start_date: start_date)
           worker.push_acknowledgement
         end
       end
 
-      def self.start_pull_worker
+      def self.start_pull_worker(start_date: nil)
         start_worker('pull_worker') do
-          worker = PullWorker.new(lims_api)
+          worker = PullWorker.new(lims_api, start_date: start_date)
 
           worker.pull_orders
         end
       end
 
-      def self.start_realtime_pull_worker
+      def self.start_realtime_pull_worker(start_date: nil)
         start_worker('realtime_pull_worker') do
-          worker = PullWorker.new(Lims::Api::WsApi.new(Lab::Lims::Config.updates_socket))
+          worker = PullWorker.new(Lims::Api::WsApi.new(Lab::Lims::Config.updates_socket), start_date: start_date)
 
           worker.pull_orders
         end

data/app/services/lab/metadata.rb

@@ -12,6 +12,7 @@ module Lab
     TEST_RESULT_INDICATOR_CONCEPT_NAME = 'Lab test result indicator'
     TEST_TYPE_CONCEPT_NAME = 'Test type'
     LAB_ORDER_STATUS_CONCEPT_NAME = 'lab order status'
+    LAB_TEST_STATUS_CONCEPT_NAME = 'lab test status'
     UNKNOWN_SPECIMEN = 'Unknown'
     VISIT_TYPE_UUID = '8a4a4488-c2cc-11de-8d13-0010c6dffd0f'
     TEST_METHOD_CONCEPT_NAME = 'Recommended test method'

data/app/services/lab/notification_service.rb

@@ -30,8 +30,7 @@ class Lab::NotificationService
   def create_notification(alert_type, alert_message)
     return if alert_type != 'LIMS'
 
-    # Use unscoped to find user regardless of location context
-    lab = User.unscoped.find_by(username: 'lab_daemon')
+    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)

data/app/services/lab/orders_service.rb

@@ -60,8 +60,14 @@ module Lab
 
           attach_test_method(order, order_params) if order_params[:test_method]
 
+          # Create initial order status trail
+          create_initial_order_status_trail(order)
+
           Lab::TestsService.create_tests(order, order_params[:date], order_params[:tests])
 
+          # Reload order to include status trails and tests
+          order = Lab::LabOrder.prefetch_relationships.find(order.order_id)
+
           Lab::LabOrderSerializer.serialize_order(
             order, requesting_clinician: add_requesting_clinician(order, order_params),
                    reason_for_test: add_reason_for_test(order, order_params),
@@ -102,14 +108,16 @@ module Lab
 
         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, force_update: params.fetch('force_update', false))
+          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 comment_to_fulfiller], 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)
@@ -140,14 +148,55 @@ module Lab
             value_text: order_params['status'],
             creator: User.current.id
           )
+
+          # Save order status trail if available
+          save_order_status_trail(order, order_params) if order_params['status']
         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'])
+        # Extract tracking number from nested structure if present
+        tracking_number = order_params['tracking_number'] || order_params.dig('order', 'tracking_number')
+        order = find_order(tracking_number)
+
         order_dto = Lab::Lims::OrderSerializer.serialize_order(order)
-        patch_order_dto_with_lims_results!(order_dto, order_params['results'])
+
+        # Handle results if present in the old format
+        patch_order_dto_with_lims_results!(order_dto, order_params['results']) if order_params['results']
+
+        # Handle test results in NLIMS format
+        if order_params['tests']
+          # Extract test results from NLIMS tests payload
+          test_results = {}
+          order_params['tests'].each do |test_data|
+            test_name = test_data.dig('test_type', 'name')
+            next unless test_name && test_data['test_results']
+
+            test_results[test_name] = {
+              'results' => test_data['test_results'].each_with_object({}) do |result, formatted|
+                measure_name = result.dig('measure', 'name')
+                result_value = result.dig('result', 'value')
+                next unless measure_name && result_value
+
+                formatted[measure_name] = { 'result_value' => result_value }
+              end,
+              'result_date' => test_data['test_results'].first&.dig('result', 'result_date'),
+              'result_entered_by' => {}
+            }
+          end
+
+          patch_order_dto_with_lims_results!(order_dto, test_results) unless test_results.empty?
+        end
+
+        # Save order status trail if available from NLIMS
+        if order_params['order'] && order_params['order']['status_trail']
+          save_order_status_trails_from_nlims(order, order_params['order']['status_trail'])
+        end
+
+        # Save test status trails if available from NLIMS
+        save_test_status_trails_from_nlims(order, order_params['tests']) if order_params['tests']
+
         Lab::Lims::PullWorker.new(nil).process_order(order_dto)
       end
 
@@ -160,13 +209,15 @@ module Lab
           last_order_date: Lab::LabOrder.last&.start_date&.to_date,
           lab_orders: []
         }
-        data[:lab_orders] = orders.map do |order|
-          Lab::LabOrderSerializer.serialize_order(
-            order, requesting_clinician: order.requesting_clinician,
-                   reason_for_test: order.reason_for_test,
-                   target_lab: order.target_lab
-          )
-        end if include_data
+        if include_data
+          data[:lab_orders] = orders.map do |order|
+            Lab::LabOrderSerializer.serialize_order(
+              order, requesting_clinician: order.requesting_clinician,
+                     reason_for_test: order.reason_for_test,
+                     target_lab: order.target_lab
+            )
+          end
+        end
         data
       end
 
@@ -174,14 +225,14 @@ 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
+        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
         NotificationService.new.create_notification('LIMS', data)
       end
 
@@ -235,7 +286,9 @@ module Lab
         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?
+        if Encounter.column_names.include?('program_id') && order_params[:program_id].present?
+          encounter.program_id = order_params[:program_id]
+        end
         encounter.save!
         encounter.reload
       end
@@ -247,6 +300,7 @@ module Lab
 
         concept = params.dig(:specimen, :concept)
         concept ||= params.dig(:specimen, :concept_id)
+        concept ||= unknown_concept_id
 
         order_type = nil
         order_type = OrderType.find_by_order_type_id!(params[:order_type_id])&.id if params[:order_type_id].present?
@@ -259,7 +313,7 @@ module Lab
         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]
-        # Note: comment_to_fulfiller is a has_one association, not a field
+        # NOTE: comment_to_fulfiller is a has_one association, not a field
         # It will be created via add_comment_to_fulfiller method
         order.accession_number = access_number
         order.orderer = User.current&.user_id
@@ -331,8 +385,7 @@ module Lab
       end
 
       def create_order_observation(order, concept_name, date, **values)
-        # Use unscoped to find user regardless of location context
-        creator = User.unscoped.find_by(username: 'lab_daemon')
+        creator = User.find_by(username: 'lab_daemon')
         User.current ||= creator
         Observation.create!(
           order:,
@@ -349,7 +402,7 @@ module Lab
       end
 
       def unknown_concept_id
-        ConceptName.find_by_name!('Unknown').concept
+        ConceptName.find_by_name!('Unknown').concept_id
       end
 
       def update_reason_for_test(order, concept_id, force_update: false)
@@ -357,7 +410,10 @@ module Lab
 
         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 && !force_update
+        if order.reason_for_test&.value_coded && !force_update
+          raise InvalidParameterError,
+                "Can't change reason for test once set"
+        end
 
         order.reason_for_test&.delete
         date = order.start_date if order.respond_to?(:start_date)
@@ -370,6 +426,150 @@ module Lab
           obs.void('New Status Received from LIMS')
         end
       end
+
+      def create_initial_order_status_trail(order)
+        create_order_status_observation(
+          order: order,
+          status: 'Drawn',
+          timestamp: order.start_date || order.date_created || Time.now,
+          updated_by: {
+            'first_name' => User.current&.person&.names&.first&.given_name,
+            'last_name' => User.current&.person&.names&.first&.family_name,
+            'id' => User.current&.user_id&.to_s,
+            'phone_number' => nil
+          }
+        )
+      rescue StandardError => e
+        Rails.logger.warn("Failed to create initial order status trail: #{e.message}")
+      end
+
+      def save_order_status_trail(order, status_params)
+        create_order_status_observation(
+          order: order,
+          status: status_params['status'],
+          timestamp: status_params['status_time'] || Time.now,
+          updated_by: status_params['updated_by'] || {}
+        )
+      end
+
+      def save_order_status_trails_from_nlims(order, status_trail)
+        return unless status_trail.is_a?(Array)
+
+        status_trail.each do |trail_entry|
+          create_order_status_observation(
+            order: order,
+            status: trail_entry['status'],
+            timestamp: trail_entry['timestamp'],
+            updated_by: trail_entry['updated_by'] || {}
+          )
+        end
+      end
+
+      def save_test_status_trails_from_nlims(order, tests)
+        return unless tests.is_a?(Array)
+
+        tests.each do |test_data|
+          next unless test_data['status_trail'].is_a?(Array)
+
+          # Find the test by test_type
+          test_name = test_data.dig('test_type', 'name')
+          next unless test_name
+
+          # Find concept for this test
+          concept = Lab::Lims::Utils.find_concept_by_name(test_name)
+          next unless concept
+
+          # Find the test observation
+          test = order.tests.find_by(value_coded: concept.concept_id)
+          next unless test
+
+          # Save each status trail entry
+          test_data['status_trail'].each do |trail_entry|
+            create_test_status_observation(
+              test: test,
+              status: trail_entry['status'],
+              timestamp: trail_entry['timestamp'],
+              updated_by: trail_entry['updated_by'] || {}
+            )
+          end
+        end
+      end
+
+      # Creates an observation for order status trail using obs table
+      def create_order_status_observation(order:, status:, timestamp:, updated_by: {})
+        # Find concept
+        order_status_concept = ConceptName.find_by(name: 'Lab Order Status')&.concept
+
+        unless order_status_concept
+          Rails.logger.warn('Missing Lab Order Status concept')
+          return
+        end
+
+        # Check if this exact status already exists
+        return if Observation.unscoped.exists?(
+          person_id: order.patient_id,
+          order_id: order.order_id,
+          concept_id: order_status_concept.concept_id,
+          value_text: status,
+          obs_datetime: timestamp,
+          voided: 0
+        )
+
+        # Create status observation
+        Observation.create!(
+          person_id: order.patient_id,
+          encounter_id: order.encounter_id,
+          order_id: order.order_id,
+          concept_id: order_status_concept.concept_id,
+          value_text: status, # Store status as text
+          obs_datetime: timestamp,
+          comments: updated_by.to_json,
+          creator: User.current&.user_id || 1,
+          date_created: Time.now,
+          uuid: SecureRandom.uuid
+        )
+      rescue StandardError => e
+        Rails.logger.error("Failed to create order status observation: #{e.message}")
+        Rails.logger.error(e.backtrace.first(5).join("\n"))
+      end
+
+      # Creates an observation for test status trail using obs table
+      def create_test_status_observation(test:, status:, timestamp:, updated_by: {})
+        # Find concept
+        test_status_concept = ConceptName.find_by(name: 'Lab Test Status')&.concept
+
+        unless test_status_concept
+          Rails.logger.warn('Missing Lab Test Status concept')
+          return
+        end
+
+        # Check if this exact status already exists
+        return if Observation.unscoped.exists?(
+          person_id: test.person_id,
+          obs_group_id: test.obs_id,
+          concept_id: test_status_concept.concept_id,
+          value_text: status,
+          obs_datetime: timestamp,
+          voided: 0
+        )
+
+        # Create status observation
+        Observation.create!(
+          person_id: test.person_id,
+          encounter_id: test.encounter_id,
+          obs_group_id: test.obs_id, # Link to parent test observation
+          concept_id: test_status_concept.concept_id,
+          value_text: status, # Store status as text
+          obs_datetime: timestamp,
+          comments: updated_by.to_json,
+          creator: User.current&.user_id || 1,
+          date_created: Time.now,
+          uuid: SecureRandom.uuid
+        )
+      rescue StandardError => e
+        Rails.logger.error("Failed to create test status observation: #{e.message}")
+        Rails.logger.error(e.backtrace.first(5).join("\n"))
+      end
     end
   end
 end

data/app/services/lab/results_service.rb

@@ -65,7 +65,7 @@ module Lab
                  order_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(User.unscoped.find(order.creator).person_id)&.name,
+                 '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

data/app/services/lab/tests_service.rb

@@ -14,8 +14,7 @@ module Lab
 
         tests = filter_tests(tests, test_type_id: filters.delete(:test_type_id),
                                     patient_id: filters.delete(:patient_id),
-                                    patient: filters.delete(:patient)
-                                    )
+                                    patient: filters.delete(:patient))
 
         tests = filter_tests_by_results(tests) if %w[1 true].include?(filters[:pending_results]&.downcase)
 
@@ -29,12 +28,11 @@ module Lab
       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,
@@ -45,6 +43,9 @@ module Lab
               value_coded: concept_id
             )
 
+            # Create initial test status trail
+            create_initial_test_status_trail(test, date)
+
             Lab::TestSerializer.serialize(test, order:)
           end
         end
@@ -100,6 +101,49 @@ module Lab
           value_coded: test_type_id
         )
       end
+
+      def create_initial_test_status_trail(test, date)
+        # Find concept
+        test_status_concept = ConceptName.find_by(name: 'Lab Test Status')&.concept
+
+        unless test_status_concept
+          Rails.logger.warn('Missing Lab Test Status concept')
+          return
+        end
+
+        timestamp = date || test.obs_datetime || Time.now
+
+        # Check if 'Drawn' status already exists for this test
+        return if Observation.unscoped.exists?(
+          person_id: test.person_id,
+          obs_group_id: test.obs_id,
+          concept_id: test_status_concept.concept_id,
+          value_text: 'Drawn',
+          voided: 0
+        )
+
+        # Create status observation with 'Drawn' as initial status
+        Observation.create!(
+          person_id: test.person_id,
+          encounter_id: test.encounter_id,
+          obs_group_id: test.obs_id, # Link to parent test observation
+          concept_id: test_status_concept.concept_id,
+          value_text: 'Drawn', # Store status as text
+          obs_datetime: timestamp,
+          status: 'FINAL',
+          comments: {
+            'first_name' => User.current&.person&.names&.first&.given_name,
+            'last_name' => User.current&.person&.names&.first&.family_name,
+            'id' => User.current&.user_id&.to_s,
+            'phone_number' => nil
+          }.to_json,
+          creator: User.current&.user_id || 1,
+          date_created: Time.now,
+          uuid: SecureRandom.uuid
+        )
+      rescue StandardError => e
+        Rails.logger.warn("Failed to create initial test status trail: #{e.message}")
+      end
     end
   end
 end

data/app/services/lab/user_service.rb

@@ -15,8 +15,7 @@ module Lab
       end
 
       def authenticate_user(username:, password:, user_agent:, request_ip:)
-        # Use unscoped for authentication - should not be location-dependent
-        user = User.unscoped.find_by_username username
+        user = User.find_by_username username
         encrypted_pass = Password.new(user.password)
         if encrypted_pass == password
           generate_token(user, user_agent, request_ip)
@@ -31,7 +30,7 @@ module Lab
       ##
       # Validate that the username doesn't already exists
       def validate(username:)
-        raise UnprocessableEntityError, 'Username already exists' if User.unscoped.find_by_username username
+        raise UnprocessableEntityError, 'Username already exists' if User.find_by_username username
       end
 
       def create_lims_person

data/db/migrate/20260226065149_create_lab_status_concepts.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# This migration creates concepts for lab order and test status tracking using obs table
+# Status values are stored as text (value_text), not coded values
+class CreateLabStatusConcepts < ActiveRecord::Migration[5.2]
+  def up
+    ActiveRecord::Base.transaction do
+      # Find concept class and datatype
+      concept_class = ConceptClass.find_by(name: 'Finding') || ConceptClass.find_by(name: 'Misc')
+      text_datatype = ConceptDatatype.find_by(name: 'Text')
+
+      # Create Lab Order Status concept (stores status as value_text)
+      unless ConceptName.exists?(name: 'Lab Order Status')
+        order_status_concept = create_concept(
+          name: 'Lab Order Status',
+          class_id: concept_class.id,
+          datatype_id: text_datatype.id,
+          is_set: 0
+        )
+        puts "Created 'Lab Order Status' concept with ID: #{order_status_concept.concept_id}"
+      end
+
+      # Create Lab Test Status concept (stores status as value_text)
+      unless ConceptName.exists?(name: 'Lab Test Status')
+        test_status_concept = create_concept(
+          name: 'Lab Test Status',
+          class_id: concept_class.id,
+          datatype_id: text_datatype.id,
+          is_set: 0
+        )
+        puts "Created 'Lab Test Status' concept with ID: #{test_status_concept.concept_id}"
+      end
+
+      puts 'Lab status concepts created successfully'
+    end
+  end
+
+  def down
+    ActiveRecord::Base.transaction do
+      # Remove concepts
+      concepts_to_remove = ['Lab Order Status', 'Lab Test Status']
+
+      concepts_to_remove.each do |name|
+        concept = ConceptName.find_by(name: name)&.concept
+        next unless concept
+
+        ConceptName.where(concept: concept).destroy_all
+        concept.destroy
+      end
+    end
+  end
+
+  private
+
+  def create_concept(name:, class_id:, datatype_id:, is_set:)
+    concept = Concept.create!(
+      class_id: class_id,
+      datatype_id: datatype_id,
+      short_name: name,
+      retired: 0,
+      is_set: is_set,
+      creator: 1,
+      date_created: Time.current,
+      uuid: SecureRandom.uuid
+    )
+
+    ConceptName.create!(
+      concept: concept,
+      name: name,
+      locale: 'en',
+      locale_preferred: 1,
+      concept_name_type: 'FULLY_SPECIFIED',
+      creator: 1,
+      date_created: Time.current,
+      uuid: SecureRandom.uuid
+    )
+
+    concept
+  end
+end